/// <summary> /// Generates a calli sequence that is aware of fat function pointers and can unwrap them into /// a function pointer + instantiation argument if necessary. /// </summary> public static void EmitTransformedCalli(ILEmitter emitter, ILCodeStream codestream, MethodSignature targetSignature) { TypeSystemContext context = targetSignature.ReturnType.Context; int thisPointerParamDelta = 0; if (!targetSignature.IsStatic) thisPointerParamDelta = 1; // Start by saving the pointer to call and all the args into locals ILLocalVariable vPointerToCall = emitter.NewLocal(context.GetWellKnownType(WellKnownType.IntPtr)); codestream.EmitStLoc(vPointerToCall); ILLocalVariable[] vParameters = new ILLocalVariable[targetSignature.Length + thisPointerParamDelta]; for (int i = thisPointerParamDelta; i < vParameters.Length; i++) { vParameters[vParameters.Length - i - 1 + thisPointerParamDelta] = emitter.NewLocal(targetSignature[targetSignature.Length - (i - thisPointerParamDelta) - 1]); codestream.EmitStLoc(vParameters[vParameters.Length - i - 1 + thisPointerParamDelta]); } if (!targetSignature.IsStatic) { vParameters[0] = emitter.NewLocal(context.GetWellKnownType(WellKnownType.Object)); codestream.EmitStLoc(vParameters[0]); } // Is this a fat pointer? codestream.EmitLdLoc(vPointerToCall); Debug.Assert(((FatFunctionPointerConstants.Offset - 1) & FatFunctionPointerConstants.Offset) == 0); codestream.EmitLdc(FatFunctionPointerConstants.Offset); codestream.Emit(ILOpcode.and); ILCodeLabel notAFatPointer = emitter.NewCodeLabel(); codestream.Emit(ILOpcode.brfalse, notAFatPointer); // // Fat pointer case // codestream.EmitLdLoc(vPointerToCall); codestream.EmitLdc(FatFunctionPointerConstants.Offset); codestream.Emit(ILOpcode.sub); // Get the pointer to call from the fat pointer codestream.Emit(ILOpcode.dup); codestream.Emit(ILOpcode.ldind_i); codestream.EmitStLoc(vPointerToCall); // Get the instantiation argument codestream.EmitLdc(context.Target.PointerSize); codestream.Emit(ILOpcode.add); codestream.Emit(ILOpcode.ldind_i); codestream.Emit(ILOpcode.ldind_i); ILLocalVariable instArg = emitter.NewLocal(context.GetWellKnownType(WellKnownType.IntPtr)); codestream.EmitStLoc(instArg); // Load this int firstRealParameter = 0; if (!targetSignature.IsStatic) { codestream.EmitLdLoc(vParameters[0]); firstRealParameter = 1; } // Load hidden arg codestream.EmitLdLoc(instArg); // Load rest of args for (int i = firstRealParameter; i < vParameters.Length; i++) { codestream.EmitLdLoc(vParameters[i]); } codestream.EmitLdLoc(vPointerToCall); // The signature has a hidden argument TypeDesc[] newParameters = new TypeDesc[targetSignature.Length + 1]; for (int i = 0; i < targetSignature.Length; i++) newParameters[i + 1] = targetSignature[i]; newParameters[0] = context.GetWellKnownType(WellKnownType.IntPtr); MethodSignature newMethodSignature = new MethodSignature(targetSignature.Flags, targetSignature.GenericParameterCount, targetSignature.ReturnType, newParameters); codestream.Emit(ILOpcode.calli, emitter.NewToken(newMethodSignature)); ILCodeLabel done = emitter.NewCodeLabel(); codestream.Emit(ILOpcode.br, done); // // Not a fat pointer case // codestream.EmitLabel(notAFatPointer); for (int i = 0; i < vParameters.Length; i++) { codestream.EmitLdLoc(vParameters[i]); } codestream.EmitLdLoc(vPointerToCall); codestream.Emit(ILOpcode.calli, emitter.NewToken(targetSignature)); codestream.EmitLabel(done); }
public override MethodIL EmitIL() { ILEmitter emitter = new ILEmitter(); ILCodeStream argSetupStream = emitter.NewCodeStream(); ILCodeStream thisCallSiteSetupStream = emitter.NewCodeStream(); ILCodeStream staticCallSiteSetupStream = emitter.NewCodeStream(); // This function will look like // // !For each parameter to the method // !if (parameter is In Parameter) // localX is TypeOfParameterX& // ldtoken TypeOfParameterX // call DynamicInvokeParamHelperIn(RuntimeTypeHandle) // stloc localX // !else // localX is TypeOfParameter // ldtoken TypeOfParameterX // call DynamicInvokeParamHelperRef(RuntimeTypeHandle) // stloc localX // ldarg.2 // call DynamicInvokeArgSetupComplete(ref ArgSetupState) // *** Thiscall instruction stream starts here *** // ldarg.3 // Load targetIsThisCall // brfalse Not_this_call // ldarg.0 // Load this pointer // !For each parameter // !if (parameter is In Parameter) // ldloc localX // ldobj TypeOfParameterX // !else // ldloc localX // ldarg.1 // calli ReturnType thiscall(TypeOfParameter1, ...) // !if ((ReturnType == void) // ldnull // !else // box ReturnType // ret // *** Static call instruction stream starts here *** // Not_this_call: // !For each parameter // !if (parameter is In Parameter) // ldloc localX // ldobj TypeOfParameterX // !else // ldloc localX // ldarg.1 // calli ReturnType (TypeOfParameter1, ...) // !if ((ReturnType == void) // ldnull // !else // box ReturnType // ret ILCodeLabel lStaticCall = emitter.NewCodeLabel(); thisCallSiteSetupStream.EmitLdArg(3); // targetIsThisCall thisCallSiteSetupStream.Emit(ILOpcode.brfalse, lStaticCall); staticCallSiteSetupStream.EmitLabel(lStaticCall); thisCallSiteSetupStream.EmitLdArg(0); // thisPtr ILToken tokDynamicInvokeParamHelperRef = emitter.NewToken(InvokeUtilsType.GetKnownMethod("DynamicInvokeParamHelperRef", null)); ILToken tokDynamicInvokeParamHelperIn = emitter.NewToken(InvokeUtilsType.GetKnownMethod("DynamicInvokeParamHelperIn", null)); TypeDesc[] targetMethodSignature = new TypeDesc[_targetSignature.Length]; for (int paramIndex = 0; paramIndex < _targetSignature.Length; paramIndex++) { TypeDesc paramType = Context.GetSignatureVariable(paramIndex, true); ILToken tokParamType = emitter.NewToken(paramType); ILLocalVariable local = emitter.NewLocal(paramType.MakeByRefType()); thisCallSiteSetupStream.EmitLdLoc(local); staticCallSiteSetupStream.EmitLdLoc(local); argSetupStream.Emit(ILOpcode.ldtoken, tokParamType); if (_targetSignature[paramIndex] == DynamicInvokeMethodParameterKind.Reference) { argSetupStream.Emit(ILOpcode.call, tokDynamicInvokeParamHelperRef); targetMethodSignature[paramIndex] = paramType.MakeByRefType(); } else { argSetupStream.Emit(ILOpcode.call, tokDynamicInvokeParamHelperIn); thisCallSiteSetupStream.Emit(ILOpcode.ldobj, tokParamType); staticCallSiteSetupStream.Emit(ILOpcode.ldobj, tokParamType); targetMethodSignature[paramIndex] = paramType; } argSetupStream.EmitStLoc(local); } argSetupStream.EmitLdArg(2); // argSetupState argSetupStream.Emit(ILOpcode.call, emitter.NewToken(InvokeUtilsType.GetKnownMethod("DynamicInvokeArgSetupComplete", null))); thisCallSiteSetupStream.EmitLdArg(1); // methodToCall staticCallSiteSetupStream.EmitLdArg(1); // methodToCall TypeDesc returnType = _targetSignature.HasReturnValue ? Context.GetSignatureVariable(_targetSignature.Length, true) : Context.GetWellKnownType(WellKnownType.Void); MethodSignature thisCallMethodSig = new MethodSignature(0, 0, returnType, targetMethodSignature); CalliIntrinsic.EmitTransformedCalli(emitter, thisCallSiteSetupStream, thisCallMethodSig); //thisCallSiteSetupStream.Emit(ILOpcode.calli, emitter.NewToken(thisCallMethodSig)); MethodSignature staticCallMethodSig = new MethodSignature(MethodSignatureFlags.Static, 0, returnType, targetMethodSignature); CalliIntrinsic.EmitTransformedCalli(emitter, staticCallSiteSetupStream, staticCallMethodSig); //staticCallSiteSetupStream.Emit(ILOpcode.calli, emitter.NewToken(staticCallMethodSig)); if (_targetSignature.HasReturnValue) { ILToken tokReturnType = emitter.NewToken(returnType); thisCallSiteSetupStream.Emit(ILOpcode.box, tokReturnType); staticCallSiteSetupStream.Emit(ILOpcode.box, tokReturnType); } else { thisCallSiteSetupStream.Emit(ILOpcode.ldnull); staticCallSiteSetupStream.Emit(ILOpcode.ldnull); } thisCallSiteSetupStream.Emit(ILOpcode.ret); staticCallSiteSetupStream.Emit(ILOpcode.ret); return(emitter.Link(this)); }