public unsafe static void RhpDebugFuncEvalHelper(IntPtr unusedTransitionBlock, IntPtr classlibAddress)
{
IntPtr pDebugFuncEvalHelper = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromCodeAddress(classlibAddress, ClassLibFunctionId.DebugFuncEvalHelper);
Debug.Assert(pDebugFuncEvalHelper != IntPtr.Zero);
CalliIntrinsics.CallVoid(pDebugFuncEvalHelper);
}
internal EEType *GetArrayEEType()
{
fixed(EEType *pThis = &this)
{
IntPtr pGetArrayEEType = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(new IntPtr(pThis), ClassLibFunctionId.GetSystemArrayEEType);
return((EEType *)CalliIntrinsics.Call <IntPtr>(pGetArrayEEType));
}
}
/// <summary>
/// Retrieve the corresponding P/invoke instance from the stub
/// </summary>
public static Delegate GetPInvokeDelegateForStub(IntPtr pStub, RuntimeTypeHandle delegateType)
{
if (pStub == IntPtr.Zero)
{
return(null);
}
//
// First try to see if this is one of the thunks we've allocated when we marshal a managed
// delegate to native code
// s_thunkPoolHeap will be null if there isn't any managed delegate to native
//
IntPtr pContext;
IntPtr pTarget;
if (s_thunkPoolHeap != null && RuntimeAugments.TryGetThunkData(s_thunkPoolHeap, pStub, out pContext, out pTarget))
{
GCHandle handle;
unsafe
{
// Pull out Handle from context
handle = (*((ThunkContextData *)pContext)).Handle;
}
Delegate target = InteropExtensions.UncheckedCast <Delegate>(handle.Target);
//
// The delegate might already been garbage collected
// User should use GC.KeepAlive or whatever ways necessary to keep the delegate alive
// until they are done with the native function pointer
//
if (target == null)
{
Environment.FailFast(SR.Delegate_GarbageCollected);
}
return(target);
}
//
// Otherwise, the stub must be a pure native function pointer
// We need to create the delegate that points to the invoke method of a
// NativeFunctionPointerWrapper derived class
//
McgPInvokeDelegateData pinvokeDelegateData;
if (!RuntimeAugments.InteropCallbacks.TryGetMarshallerDataForDelegate(delegateType, out pinvokeDelegateData))
{
Environment.FailFast("Couldn't find marshalling stubs for delegate.");
}
return(CalliIntrinsics.Call <Delegate>(
pinvokeDelegateData.ForwardDelegateCreationStub,
pStub
));
}
internal EEType *GetArrayEEType()
{
#if INPLACE_RUNTIME
return(EETypePtr.EETypePtrOf <Array>().ToPointer());
#else
fixed(EEType *pThis = &this)
{
IntPtr pGetArrayEEType = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(new IntPtr(pThis), ClassLibFunctionId.GetSystemArrayEEType);
return((EEType *)CalliIntrinsics.Call <IntPtr>(pGetArrayEEType));
}
#endif
}
private static unsafe void RunEagerClassConstructors()
{
int length = 0;
IntPtr cctorTableStart = GetModuleSection((int)ModuleSectionIds.EagerCctorStart, out length);
Debug.Assert(length % IntPtr.Size == 0);
IntPtr cctorTableEnd = (IntPtr)((byte *)cctorTableStart + length);
for (IntPtr *tab = (IntPtr *)cctorTableStart; tab < (IntPtr *)cctorTableEnd; tab++)
{
CalliIntrinsics.Call <int>(*tab);
}
}
internal EEType *GetArrayEEType()
{
fixed(EEType *pThis = &this)
{
IntPtr pGetArrayEEType = (IntPtr)InternalCalls.RhpGetClasslibFunctionFromEEType(new IntPtr(pThis), ClassLibFunctionId.GetSystemArrayEEType);
if (pGetArrayEEType != IntPtr.Zero)
{
return((EEType *)CalliIntrinsics.Call <IntPtr>(pGetArrayEEType));
}
}
#if PROJECTN
fixed(EEType *pThis = &this)
return(InternalCalls.RhpGetArrayBaseType(pThis));
#else
EH.FallbackFailFast(RhFailFastReason.InternalError, null);
return(null);
#endif
}
internal Exception GetClasslibException(ExceptionIDs id)
{
#if INPLACE_RUNTIME
return(RuntimeExceptionHelpers.GetRuntimeException(id));
#else
DynamicModule *dynamicModule = this.DynamicModule;
if (dynamicModule != null)
{
IntPtr getRuntimeException = dynamicModule->GetRuntimeException;
if (getRuntimeException != IntPtr.Zero)
{
return(CalliIntrinsics.Call <Exception>(getRuntimeException, id));
}
}
if (IsParameterizedType)
{
return(RelatedParameterType->GetClasslibException(id));
}
return(EH.GetClasslibExceptionFromEEType(id, GetAssociatedModuleAddress()));
#endif
}
internal static object CallDynamicInvokeMethod(
object thisPtr,
IntPtr methodToCall,
object thisPtrDynamicInvokeMethod,
IntPtr dynamicInvokeHelperMethod,
IntPtr dynamicInvokeHelperGenericDictionary,
object targetMethodOrDelegate,
object[] parameters,
BinderBundle binderBundle,
bool wrapInTargetInvocationException,
bool invokeMethodHelperIsThisCall = true,
bool methodToCallIsThisCall = true)
{
// This assert is needed because we've double-purposed "targetMethodOrDelegate" (which is actually a MethodBase anytime a custom binder is used)
// as a way of obtaining the true parameter type which we need to pass to Binder.ChangeType(). (The type normally passed to DynamicInvokeParamHelperCore
// isn't always the exact type (byref stripped off, enums converted to int, etc.)
Debug.Assert(!(binderBundle != null && !(targetMethodOrDelegate is MethodBase)), "The only callers that can pass a custom binder are those servicing MethodBase.Invoke() apis.");
bool parametersNeedCopyBack = false;
ArgSetupState argSetupState = default(ArgSetupState);
// Capture state of thread static invoke helper statics
object[] parametersOld = s_parameters;
object[] nullableCopyBackObjectsOld = s_nullableCopyBackObjects;
int curIndexOld = s_curIndex;
object targetMethodOrDelegateOld = s_targetMethodOrDelegate;
BinderBundle binderBundleOld = s_binderBundle;
s_binderBundle = binderBundle;
object[] customBinderProvidedParametersOld = s_customBinderProvidedParameters;
s_customBinderProvidedParameters = null;
try
{
// If the passed in array is not an actual object[] instance, we need to copy it over to an actual object[]
// instance so that the rest of the code can safely create managed object references to individual elements.
if (parameters != null && EETypePtr.EETypePtrOf <object[]>() != parameters.EETypePtr)
{
s_parameters = new object[parameters.Length];
Array.Copy(parameters, s_parameters, parameters.Length);
parametersNeedCopyBack = true;
}
else
{
s_parameters = parameters;
}
s_nullableCopyBackObjects = null;
s_curIndex = 0;
s_targetMethodOrDelegate = targetMethodOrDelegate;
try
{
object result = null;
if (invokeMethodHelperIsThisCall)
{
Debug.Assert(methodToCallIsThisCall == true);
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, thisPtrDynamicInvokeMethod, thisPtr, methodToCall, ref argSetupState);
System.Diagnostics.DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
else
{
if (dynamicInvokeHelperGenericDictionary != IntPtr.Zero)
{
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, dynamicInvokeHelperGenericDictionary, thisPtr, methodToCall, ref argSetupState, methodToCallIsThisCall);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
else
{
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, thisPtr, methodToCall, ref argSetupState, methodToCallIsThisCall);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
}
return(result);
}
catch (Exception e) when(wrapInTargetInvocationException && argSetupState.fComplete)
{
throw new TargetInvocationException(e);
}
finally
{
if (parametersNeedCopyBack)
{
Array.Copy(s_parameters, parameters, parameters.Length);
}
if (argSetupState.fComplete)
{
// Nullable objects can't take advantage of the ability to update the boxed value on the heap directly, so perform
// an update of the parameters array now.
if (argSetupState.nullableCopyBackObjects != null)
{
for (int i = 0; i < argSetupState.nullableCopyBackObjects.Length; i++)
{
if (argSetupState.nullableCopyBackObjects[i] != null)
{
parameters[i] = DynamicInvokeBoxIntoNonNullable(argSetupState.nullableCopyBackObjects[i]);
}
}
}
}
}
}
finally
{
// Restore state of thread static helper statics
s_parameters = parametersOld;
s_nullableCopyBackObjects = nullableCopyBackObjectsOld;
s_curIndex = curIndexOld;
s_targetMethodOrDelegate = targetMethodOrDelegateOld;
s_binderBundle = binderBundleOld;
s_customBinderProvidedParameters = customBinderProvidedParametersOld;
}
}
internal static object CallDynamicInvokeMethod(
object thisPtr,
IntPtr methodToCall,
object thisPtrDynamicInvokeMethod,
IntPtr dynamicInvokeHelperMethod,
IntPtr dynamicInvokeHelperGenericDictionary,
object defaultParametersContext,
object[] parameters,
bool invokeMethodHelperIsThisCall = true,
bool methodToCallIsThisCall = true)
{
bool fDontWrapInTargetInvocationException = false;
bool parametersNeedCopyBack = false;
ArgSetupState argSetupState = default(ArgSetupState);
// Capture state of thread static invoke helper statics
object[] parametersOld = s_parameters;
object[] nullableCopyBackObjectsOld = s_nullableCopyBackObjects;
int curIndexOld = s_curIndex;
object defaultParametersContextOld = s_defaultParametersContext;
try
{
// If the passed in array is not an actual object[] instance, we need to copy it over to an actual object[]
// instance so that the rest of the code can safely create managed object references to individual elements.
if (parameters != null && EETypePtr.EETypePtrOf <object[]>() != parameters.EETypePtr)
{
s_parameters = new object[parameters.Length];
Array.Copy(parameters, s_parameters, parameters.Length);
parametersNeedCopyBack = true;
}
else
{
s_parameters = parameters;
}
s_nullableCopyBackObjects = null;
s_curIndex = 0;
s_defaultParametersContext = defaultParametersContext;
try
{
object result = null;
if (invokeMethodHelperIsThisCall)
{
Debug.Assert(methodToCallIsThisCall == true);
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, thisPtrDynamicInvokeMethod, thisPtr, methodToCall, ref argSetupState);
System.Diagnostics.DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
else
{
if (dynamicInvokeHelperGenericDictionary != IntPtr.Zero)
{
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, dynamicInvokeHelperGenericDictionary, thisPtr, methodToCall, ref argSetupState, methodToCallIsThisCall);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
else
{
result = CalliIntrinsics.Call(dynamicInvokeHelperMethod, thisPtr, methodToCall, ref argSetupState, methodToCallIsThisCall);
DebugAnnotations.PreviousCallContainsDebuggerStepInCode();
}
}
return(result);
}
finally
{
if (parametersNeedCopyBack)
{
Array.Copy(s_parameters, parameters, parameters.Length);
}
if (!argSetupState.fComplete)
{
fDontWrapInTargetInvocationException = true;
}
else
{
// Nullable objects can't take advantage of the ability to update the boxed value on the heap directly, so perform
// an update of the parameters array now.
if (argSetupState.nullableCopyBackObjects != null)
{
for (int i = 0; i < argSetupState.nullableCopyBackObjects.Length; i++)
{
if (argSetupState.nullableCopyBackObjects[i] != null)
{
parameters[i] = DynamicInvokeBoxIntoNonNullable(argSetupState.nullableCopyBackObjects[i]);
}
}
}
}
}
}
catch (Exception e)
{
if (fDontWrapInTargetInvocationException)
{
throw;
}
else
{
throw new System.Reflection.TargetInvocationException(e);
}
}
finally
{
// Restore state of thread static helper statics
s_parameters = parametersOld;
s_nullableCopyBackObjects = nullableCopyBackObjectsOld;
s_curIndex = curIndexOld;
s_defaultParametersContext = defaultParametersContextOld;
}
}
public static void RhpDebugFuncEvalHelper()
{
CalliIntrinsics.CallVoid(s_highLevelDebugFuncEvalHelper);
}
