public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object aMethodInfo)
{
// method signature: $this, object @object, IntPtr method
var xAssembler = aAssembler;
var xMethodInfo = (_MethodInfo)aMethodInfo;
XS.Comment("Save target ($this) to field");
XS.Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
XS.Comment("-- ldarg 1");
Ldarg.DoExecute(xAssembler, xMethodInfo, 1);
XS.Comment("-- stfld _target");
Stfld.DoExecute(xAssembler, xMethodInfo, "System.Object System.Delegate._target", xMethodInfo.MethodBase.DeclaringType, true, false);
XS.Comment("Save method pointer to field");
XS.Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
XS.Comment("-- ldarg 2");
Ldarg.DoExecute(xAssembler, xMethodInfo, 2);
XS.Comment("-- stfld _methodPtr");
Stfld.DoExecute(xAssembler, xMethodInfo, "System.IntPtr System.Delegate._methodPtr", xMethodInfo.MethodBase.DeclaringType, true, false);
XS.Comment("Saving ArgSize to field");
uint xSize = 0;
foreach (var xArg in xMethodInfo.MethodBase.DeclaringType.GetMethod("Invoke").GetParameters())
{
xSize += ILOp.Align(ILOp.SizeOfType(xArg.ParameterType), 4);
}
XS.Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
XS.Comment("-- push argsize");
XS.Push(xSize);
XS.Comment("-- stfld ArgSize");
Stfld.DoExecute(xAssembler, xMethodInfo, "$$ArgSize$$", xMethodInfo.MethodBase.DeclaringType, true, false);
}
public override void AssembleNew(Cosmos.Assembler.Assembler aAssembler, object aMethodInfo)
{
// method signature: $this, object @object, IntPtr method
var xMethodInfo = (MethodInfo)aMethodInfo;
var xAssembler = (NewAssembler)aAssembler;
new Comment("Save target ($this) to field");
new Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
//Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
new Comment("-- ldarg 1");
Ldarg.DoExecute(xAssembler, xMethodInfo, 1);
new Comment("-- stfld _target");
Stfld.DoExecute(xAssembler, xMethodInfo, "System.Object System.Delegate._target", xMethodInfo.MethodBase.DeclaringType, true, false);
new Comment("Save method pointer to field");
//Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
new Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
new Comment("-- ldarg 2");
Ldarg.DoExecute(xAssembler, xMethodInfo, 2);
new Comment("-- stfld _methodPtr");
Stfld.DoExecute(xAssembler, xMethodInfo, "System.IntPtr System.Delegate._methodPtr", xMethodInfo.MethodBase.DeclaringType, true, false);
new Comment("Saving ArgSize to field");
uint xSize = 0;
foreach (var xArg in xMethodInfo.MethodBase.DeclaringType.GetMethod("Invoke").GetParameters())
{
xSize += ILOp.Align(ILOp.SizeOfType(xArg.ParameterType), 4);
}
new Comment("-- ldarg 0");
Ldarg.DoExecute(xAssembler, xMethodInfo, 0);
if (xMethodInfo.MethodBase.DeclaringType.FullName.Contains("InterruptDelegate"))
{
Console.Write("");
}
new Comment("-- push argsize");
new CPUx86.Push {
DestinationValue = xSize
};
new Comment("-- stfld ArgSize");
Stfld.DoExecute(xAssembler, xMethodInfo, "$$ArgSize$$", xMethodInfo.MethodBase.DeclaringType, true, false);
//public static void Ctor(Delegate aThis, object aObject, IntPtr aMethod,
//[FieldAccess(Name = "System.Object System.Delegate._target")] ref object aFldTarget,
//[FieldAccess(Name = "System.IntPtr System.Delegate._methodPtr")] ref IntPtr aFldMethod) {
}
public override void AssembleNew(Assembler aAssembler, object aMethodInfo)
{
var xAssembler = aAssembler;
var xMethodInfo = (_MethodInfo)aMethodInfo;
var xMethodBaseAsInfo = xMethodInfo.MethodBase as global::System.Reflection.MethodInfo;
if (xMethodBaseAsInfo.ReturnType != typeof(void))
{
throw new Exception("Events with return type not yet supported!");
}
/*
* EAX contains the GetInvocationList() array at the index at which it was last used
* EDX contains the index at which the EAX is
* EBX contains the number of items in the array
* ECX contains the argument size
*/
XS.ClearInterruptFlag();
XS.Comment("Get Invoke list count");
var xGetInvocationListMethod = typeof(MulticastDelegate).GetMethod("GetInvocationList");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Call(LabelName.Get(xGetInvocationListMethod));
XS.Add(XSRegisters.ESP, 4);
XS.Pop(XSRegisters.EAX);
XS.Add(XSRegisters.EAX, 8);
XS.Set(XSRegisters.EBX, XSRegisters.EAX, sourceIsIndirect: true);
XS.Comment("Get invoke method");
XS.Add(XSRegisters.EAX, 8);
XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true, sourceDisplacement: 4);
XS.Comment("Get ArgSize");
int xArgSizeOffset = Ldfld.GetFieldOffset(typeof(global::System.Delegate), "$$ArgSize$$");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Add(XSRegisters.ESP, 4);
XS.Pop(XSRegisters.ECX);
XS.Add(XSRegisters.ECX, (uint)xArgSizeOffset);
XS.Set(XSRegisters.ECX, XSRegisters.ECX, sourceIsIndirect: true);
XS.Comment("Set current invoke list index");
XS.Set(XSRegisters.EDX, 0);
XS.Label(".BEGIN_OF_LOOP");
{
XS.Compare(XSRegisters.EDX, XSRegisters.EBX);
XS.Jump(x86.ConditionalTestEnum.GreaterThanOrEqualTo, ".END_OF_INVOKE");
XS.PushAllRegisters();
XS.Comment("Check if delegate has $this");
XS.Set(XSRegisters.EDI, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));
XS.Add(XSRegisters.EDI, 4);
XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target"));
XS.Compare(XSRegisters.EDI, 0);
XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_THIS");
XS.Label(".HAS_THIS");
XS.Push(XSRegisters.EDI);
XS.Push(0);
XS.Label(".NO_THIS");
XS.Set(XSRegisters.EDI, XSRegisters.EAX, sourceIsIndirect: true, sourceDisplacement: 4);
XS.Set(XSRegisters.EDI, XSRegisters.EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr"));
XS.Comment("Check if delegate has args");
XS.Compare(XSRegisters.ECX, 0);
XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_ARGS");
XS.Label(".HAS_ARGS");
XS.Sub(XSRegisters.ESP, XSRegisters.ECX);
XS.Push(XSRegisters.EDI);
XS.Set(XSRegisters.EDI, XSRegisters.ESP);
XS.Add(XSRegisters.EDI, 4);
XS.Set(XSRegisters.ESI, XSRegisters.EBP);
XS.Add(XSRegisters.ESI, 8);
new x86.Movs {
Size = 8, Prefixes = x86.InstructionPrefixes.Repeat
};
XS.Pop(XSRegisters.EDI);
XS.Label(".NO_ARGS");
XS.Call(XSRegisters.EDI);
XS.PopAllRegisters();
XS.Increment(XSRegisters.EDX);
XS.Jump(".BEGIN_OF_LOOP");
}
XS.Label(".END_OF_INVOKE");
XS.Set(XSRegisters.EDX, XSRegisters.EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));
XS.Set(XSRegisters.EDX, XSRegisters.EDX, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "$$ReturnsValue$$"));
XS.Compare(XSRegisters.EDX, 0);
XS.Jump(x86.ConditionalTestEnum.Equal, ".NO_RETURN");
XS.Label(".HAS_RETURN");
XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 8);
XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationDisplacement: 4);
XS.Exchange(XSRegisters.EBP, XSRegisters.EDX, destinationIsIndirect: true);
XS.Push(XSRegisters.EDX);
XS.Set(XSRegisters.ESP, XSRegisters.EDI, destinationDisplacement: 12);
XS.Label(".NO_RETURN");
XS.EnableInterrupts();
}
public override void AssembleNew(Assembler aAssembler, object aMethodInfo)
{
var xMethodInfo = (Il2cpuMethodInfo)aMethodInfo;
/*
* EAX contains the GetInvocationList() array at the index at which it was last used
* EBX contains the number of items in the array
* ECX contains the argument size
* EDX contains the current index in the array
* ESI contains the size of the return value
* EDI contains the function pointer
*/
XS.ClearInterruptFlag();
XS.Comment("Get Invoke list count");
var xGetInvocationListMethod = typeof(MulticastDelegate).GetMethod("GetInvocationList");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Call(LabelName.Get(xGetInvocationListMethod));
XS.Add(ESP, 4);
XS.Pop(EAX);
XS.Add(EAX, 8);
XS.Set(EBX, EAX, sourceIsIndirect: true);
XS.Comment("Get invoke method");
XS.Add(EAX, 8);
XS.Set(EDI, EAX, sourceIsIndirect: true, sourceDisplacement: 4); // this line can propably can be removed
XS.Comment("Get ArgSize");
int xArgSizeOffset = Ldfld.GetFieldOffset(typeof(Delegate), "$$ArgSize$$");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Add(ESP, 4);
XS.Pop(ECX);
XS.Add(ECX, (uint)xArgSizeOffset);
XS.Set(ECX, ECX, sourceIsIndirect: true);
XS.Comment("Set current invoke list index");
XS.Set(EDX, 0);
XS.Comment("Make space for return value");
int returnSizeOffset = Ldfld.GetFieldOffset(typeof(Delegate), "$$ReturnSize$$");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Add(ESP, 4);
XS.Pop(ESI);
XS.Add(ESI, (uint)returnSizeOffset);
XS.Set(ESI, ESI, sourceIsIndirect: true);
XS.Sub(ESP, ESI);
XS.Label(".BEGIN_OF_LOOP");
{
XS.Compare(EDX, EBX);
XS.Jump(x86.ConditionalTestEnum.GreaterThanOrEqualTo, ".END_OF_INVOKE");
XS.PushAllRegisters();
XS.Comment("Check if delegate has $this");
XS.Set(EDI, EBP, sourceDisplacement: Ldarg.GetArgumentDisplacement(xMethodInfo, 0));
XS.Add(EDI, 4);
XS.Set(EDI, EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.Object System.Delegate._target"));
XS.Set(EDX, ECX); // edx contains the size of the arguments including $this
XS.Compare(EDI, 0);
XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_THIS");
XS.Label(".HAS_THIS");
XS.Push(EDI);
XS.Set(EDI, EDI, sourceIsIndirect: true); // get type of target object
XS.Add(EDX, 4); // we have at least one int of $this
//TODO: In future we might be able to replace the following call with a check
//if the object is boxed and in that case assume its a struct
// safe info from registers which get trashed
XS.Push(EAX);
XS.Push(EBX);
XS.Push(ECX);
XS.Push(EDX);
XS.Push(EDI);
XS.Call(LabelName.Get(VTablesImplRefs.IsStructRef));
XS.Pop(EDI);
// restore values
XS.Pop(EDX);
XS.Pop(ECX);
XS.Pop(EBX);
XS.Pop(EAX);
// now check if target turned out to be struct
XS.Compare(EDI, 1);
XS.Jump(x86.ConditionalTestEnum.Equal, ".Struct"); //structs are just the pointer so we are already done
XS.Push(0);
XS.Add(EDX, 4);
XS.Jump(".NO_THIS");
XS.Label(".Struct");
XS.Add(ESP, ObjectUtils.FieldDataOffset, destinationIsIndirect: true);
XS.Label(".NO_THIS");
XS.Set(EDI, EAX, sourceIsIndirect: true, sourceDisplacement: 4);
XS.Set(EDI, EDI, sourceDisplacement: Ldfld.GetFieldOffset(xMethodInfo.MethodBase.DeclaringType, "System.IntPtr System.Delegate._methodPtr"));
XS.Set(EBX, 0); // initialise required extra space to 0
XS.Compare(ESI, EDX);
XS.Jump(x86.ConditionalTestEnum.LessThanOrEqualTo, ".NO_RETURN_VALUE_SPACE");
XS.Set(EBX, ESI);
XS.Sub(EBX, ECX);
XS.Label(".NO_RETURN_VALUE_SPACE");
XS.Comment("Check if delegate has args");
XS.Compare(ECX, 0);
XS.Jump(x86.ConditionalTestEnum.Zero, ".NO_ARGS");
XS.Label(".HAS_ARGS");
XS.Sub(ESP, ECX);
XS.Push(EDI);
XS.Set(EDI, ESP);
XS.Add(EDI, 4);
XS.Set(ESI, EBP);
XS.Compare(EBX, 0);
XS.Jump(x86.ConditionalTestEnum.Equal, ".NO_RETURN_EXTRA");
XS.Add(ESI, EBX); // to skip the extra space reserved for the return value
XS.Jump(".AFTER_ADJUST_ESI");
XS.Label(".NO_RETURN_EXTRA");
XS.Add(ESI, 8);
XS.Label(".AFTER_ADJUST_ESI");
new x86.Movs {
Size = 8, Prefixes = x86.InstructionPrefixes.Repeat
};
XS.Pop(EDI);
XS.Label(".NO_ARGS");
XS.Sub(ESP, EBX); // make extra space for the return value
XS.Call(EDI);
XS.Comment("If there is a return value copy it to holding place now");
Ldarg.DoExecute(aAssembler, xMethodInfo, 0);
XS.Add(ESP, 4);
XS.Pop(EAX);
XS.Add(EAX, (uint)returnSizeOffset);
XS.Set(EAX, EAX, sourceIsIndirect: true); // got size of return value
XS.Set(EDI, EBP);
XS.Sub(EDI, EAX);
XS.Label(".RETURN_VALUE_LOOP_START");
XS.Compare(EAX, 0);
XS.Jump(x86.ConditionalTestEnum.LessThanOrEqualTo, ".RETURN_VALUE_LOOP_END");
XS.Pop(EBX);
XS.Set(EDI, EBX, destinationIsIndirect: true);
XS.Add(EDI, 4);
XS.Sub(EAX, 4);
XS.Jump(".RETURN_VALUE_LOOP_START");
XS.Label(".RETURN_VALUE_LOOP_END");
XS.PopAllRegisters();
XS.Increment(EDX);
XS.Jump(".BEGIN_OF_LOOP");
}
XS.Label(".END_OF_INVOKE");
XS.EnableInterrupts();
}