using System.Reflection;
using System.Text;
using System.Runtime.CompilerServices;
+using Internal.Runtime.CompilerServices;
namespace System.Diagnostics.Tracing
{
public unsafe void ThreadPoolEnqueueWorkObject(object workID)
{
// convert the Object Id to a long
- ThreadPoolEnqueueWork((long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref workID)));
+ ThreadPoolEnqueueWork((long)*((void**)Unsafe.AsPointer(ref workID)));
}
[Event(31, Level = EventLevel.Verbose, Keywords = Keywords.ThreadPool | Keywords.ThreadTransfer)]
public unsafe void ThreadPoolDequeueWorkObject(object workID)
{
// convert the Object Id to a long
- ThreadPoolDequeueWork((long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref workID)));
+ ThreadPoolDequeueWork((long)*((void**)Unsafe.AsPointer(ref workID)));
}
// In the desktop runtime they don't use Tasks for the point at which the response happens, which means that the
#endif // !CORECLR
public unsafe void ThreadTransferSendObj(object id, int kind, string info, bool multiDequeues, int intInfo1, int intInfo2)
{
- ThreadTransferSend((long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info, multiDequeues, intInfo1, intInfo2);
+ ThreadTransferSend((long)*((void**)Unsafe.AsPointer(ref id)), kind, info, multiDequeues, intInfo1, intInfo2);
}
// id - represents a correlation ID that allows correlation of two activities, one stamped by
#endif // !CORECLR
public unsafe void ThreadTransferReceiveObj(object id, int kind, string info)
{
- ThreadTransferReceive((long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info);
+ ThreadTransferReceive((long)*((void**)Unsafe.AsPointer(ref id)), kind, info);
}
// id - represents a correlation ID that allows correlation of two activities, one stamped by
#endif // !CORECLR
public unsafe void ThreadTransferReceiveHandledObj(object id, int kind, string info)
{
- ThreadTransferReceive((long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref id)), kind, info);
+ ThreadTransferReceive((long)*((void**)Unsafe.AsPointer(ref id)), kind, info);
}
// return a stable ID for a an object. We use the hash code which is not truely unique but is
// Helper class to assist with unsafe pinning of arbitrary objects.
// It's used by VM code.
- internal class PinningHelper
+ internal class RawData
{
- public byte m_data;
+ public byte Data;
}
- internal class ArrayPinningHelper
+ internal class RawSzArrayData
{
- public IntPtr m_lengthAndPadding;
- public byte m_arrayData;
+ public IntPtr Count; // Array._numComponents padded to IntPtr
+ public byte Data;
}
- internal static class JitHelpers
+ internal static unsafe class JitHelpers
{
// The special dll name to be used for DllImport of QCalls
internal const string QCall = "QCall";
// s has to be a local variable on the stack.
internal static StringHandleOnStack GetStringHandleOnStack(ref string s)
{
- return new StringHandleOnStack(UnsafeCastToStackPointer(ref s));
+ return new StringHandleOnStack((IntPtr)Unsafe.AsPointer(ref s));
}
// Wraps object variable into a handle. Used to pass managed object references in and out of QCalls.
// o has to be a local variable on the stack.
internal static ObjectHandleOnStack GetObjectHandleOnStack<T>(ref T o) where T : class
{
- return new ObjectHandleOnStack(UnsafeCastToStackPointer(ref o));
+ return new ObjectHandleOnStack((IntPtr)Unsafe.AsPointer(ref o));
}
// Wraps StackCrawlMark into a handle. Used to pass StackCrawlMark to QCalls.
// stackMark has to be a local variable on the stack.
internal static StackCrawlMarkHandle GetStackCrawlMarkHandle(ref StackCrawlMark stackMark)
{
- return new StackCrawlMarkHandle(UnsafeCastToStackPointer(ref stackMark));
+ return new StackCrawlMarkHandle((IntPtr)Unsafe.AsPointer(ref stackMark));
}
#if DEBUG
// See getILIntrinsicImplementation for how this happens.
throw new InvalidOperationException();
}
-
- // Internal method for getting a raw pointer for handles in JitHelpers.
- // The reference has to point into a local stack variable in order so it can not be moved by the GC.
- internal static IntPtr UnsafeCastToStackPointer<T>(ref T val)
- {
- IntPtr p = UnsafeCastToStackPointerInternal<T>(ref val);
- Debug.Assert(IsAddressInStack(p), "Pointer not in the stack!");
- return p;
- }
-
- private static IntPtr UnsafeCastToStackPointerInternal<T>(ref T val)
- {
- // The body of this function will be replaced by the EE with unsafe code that just returns val!!!
- // See getILIntrinsicImplementation for how this happens.
- throw new InvalidOperationException();
- }
#else // DEBUG
internal static int UnsafeEnumCast<T>(T val) where T : struct // Actually T must be 4 byte (or less) enum
// See getILIntrinsicImplementation for how this happens.
throw new InvalidOperationException();
}
-
- internal static IntPtr UnsafeCastToStackPointer<T>(ref T val)
- {
- // The body of this function will be replaced by the EE with unsafe code that just returns o!!!
- // See getILIntrinsicImplementation for how this happens.
- throw new InvalidOperationException();
- }
#endif // DEBUG
// Set the given element in the array without any type or range checks
internal static ref byte GetRawData(this object obj) =>
ref Unsafe.As<RawData>(obj).Data;
- private sealed class RawData
- {
- public byte Data;
- }
-
-#if DEBUG
- [MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool IsAddressInStack(IntPtr ptr);
-#endif
-
- internal static ref byte GetRawSzArrayData(this Array array)
- {
- // The body of this function will be replaced by the EE with unsafe code!!!
- // See getILIntrinsicImplementation for how this happens.
- typeof(ArrayPinningHelper).ToString(); // Type used by the actual method body
- throw new InvalidOperationException();
- }
+ internal static ref byte GetRawSzArrayData(this Array array) =>
+ ref Unsafe.As<RawSzArrayData>(array).Data;
}
}
using System.Runtime.CompilerServices;
using System.Security;
+using Internal.Runtime.CompilerServices;
+
namespace System.Runtime.InteropServices.WindowsRuntime
{
internal class CLRIPropertyValueImpl : IPropertyValue
fixed (byte* pData = &_data.GetRawData())
{
- byte* pUnboxed = (byte*)JitHelpers.UnsafeCastToStackPointer(ref unboxed);
+ byte* pUnboxed = (byte*)Unsafe.AsPointer(ref unboxed);
Buffer.Memcpy(pUnboxed, pData, Marshal.SizeOf(unboxed));
}
using System.Text;
using System.Security;
using System.Runtime.CompilerServices;
-
using System.Diagnostics.Tracing;
+using Internal.Runtime.CompilerServices;
+
namespace System.Threading.Tasks
{
/// <summary>Provides an event source for tracing TPL information.</summary>
}
[NonEvent]
- public unsafe void RunningContinuation(int TaskID, object Object) { RunningContinuation(TaskID, (long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref Object))); }
+ public unsafe void RunningContinuation(int TaskID, object Object) { RunningContinuation(TaskID, (long)*((void**)Unsafe.AsPointer(ref Object))); }
[Event(20, Keywords = Keywords.Debug)]
private void RunningContinuation(int TaskID, long Object)
{
}
[NonEvent]
- public unsafe void RunningContinuationList(int TaskID, int Index, object Object) { RunningContinuationList(TaskID, Index, (long)*((void**)JitHelpers.UnsafeCastToStackPointer(ref Object))); }
+ public unsafe void RunningContinuationList(int TaskID, int Index, object Object) { RunningContinuationList(TaskID, Index, (long)*((void**)Unsafe.AsPointer(ref Object))); }
[Event(21, Keywords = Keywords.Debug)]
public void RunningContinuationList(int TaskID, int Index, long Object)
DWORD dwFactorLocalNum = NewLocal(ELEMENT_TYPE_I4);
DWORD dwLengthLocalNum = NewLocal(ELEMENT_TYPE_I4);
- mdToken tokPinningHelper = GetToken(MscorlibBinder::GetField(FIELD__PINNING_HELPER__M_DATA));
+ mdToken tokRawData = GetToken(MscorlibBinder::GetField(FIELD__RAW_DATA__DATA));
ILCodeLabel * pRangeExceptionLabel = NewCodeLabel();
ILCodeLabel * pRangeExceptionLabel1 = NewCodeLabel();
m_pCode->EmitBRFALSE(pTypeCheckOK); //Storing NULL is OK
m_pCode->EmitLDARG(rank); // return param
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(Object::GetOffsetOfFirstField());
m_pCode->EmitSUB();
m_pCode->EmitLDIND_I(); // TypeHandle
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(Object::GetOffsetOfFirstField());
m_pCode->EmitSUB();
m_pCode->EmitLDIND_I(); // Array MT
m_pCode->EmitLDARG(hiddenArgIdx); // hidden param
m_pCode->EmitBRFALSE(pTypeCheckPassed);
m_pCode->EmitLDARG(hiddenArgIdx);
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(offsetof(ParamTypeDesc, m_Arg) - (Object::GetOffsetOfFirstField()+2));
m_pCode->EmitADD();
m_pCode->EmitLDIND_I();
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(Object::GetOffsetOfFirstField());
m_pCode->EmitSUB();
m_pCode->EmitLDIND_I(); // Array MT
{
// check if the array is SZArray.
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(Object::GetOffsetOfFirstField());
m_pCode->EmitSUB();
m_pCode->EmitLDIND_I();
// it is SZArray
// bounds check
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(ArrayBase::GetOffsetOfNumComponents() - Object::GetOffsetOfFirstField());
m_pCode->EmitADD();
m_pCode->EmitLDIND_I4();
m_pCode->EmitBLE_UN(pRangeExceptionLabel);
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(ArrayBase::GetBoundsOffset(pMT) - Object::GetOffsetOfFirstField());
m_pCode->EmitADD();
m_pCode->EmitLDARG(firstIdx);
{
// Cache length
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC((ArrayBase::GetBoundsOffset(pMT) - Object::GetOffsetOfFirstField()) + (idx-firstIdx)*sizeof(DWORD));
m_pCode->EmitADD();
m_pCode->EmitLDIND_I4();
{
// Load lower bound
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC((ArrayBase::GetLowerBoundsOffset(pMT) - Object::GetOffsetOfFirstField()) + (idx-firstIdx)*sizeof(DWORD));
m_pCode->EmitADD();
m_pCode->EmitLDIND_I4();
// Compute element address
m_pCode->EmitLoadThis();
- m_pCode->EmitLDFLDA(tokPinningHelper);
+ m_pCode->EmitLDFLDA(tokRawData);
m_pCode->EmitLDC(ArrayBase::GetDataPtrOffset(pMT) - Object::GetOffsetOfFirstField());
m_pCode->EmitADD();
m_pCode->EmitLDLOC(dwTotalLocalNum);
FCFuncStart(gJitHelpers)
FCFuncElement("UnsafeSetArrayElement", JitHelpers::UnsafeSetArrayElement)
-#ifdef _DEBUG
- FCFuncElement("IsAddressInStack", ReflectionInvocation::IsAddressInStack)
-#endif
FCFuncEnd()
FCFuncStart(gCOMTypeHandleFuncs)
ILCodeLabel* pNullRefLabel = pslILEmit->NewCodeLabel();
UINT uNativeSize = m_pargs->m_pMT->GetNativeSize();
- int fieldDef = pslILEmit->GetToken(MscorlibBinder::GetField(FIELD__PINNING_HELPER__M_DATA));
+ int fieldDef = pslILEmit->GetToken(MscorlibBinder::GetField(FIELD__RAW_DATA__DATA));
EmitLoadNativeValue(pslILEmit);
pslILEmit->EmitBRFALSE(pNullRefLabel);
ILCodeLabel* pNullRefLabel = pslILEmit->NewCodeLabel();
UINT uNativeSize = m_pargs->m_pMT->GetNativeSize();
- int fieldDef = pslILEmit->GetToken(MscorlibBinder::GetField(FIELD__PINNING_HELPER__M_DATA));
+ int fieldDef = pslILEmit->GetToken(MscorlibBinder::GetField(FIELD__RAW_DATA__DATA));
EmitLoadManagedValue(pslILEmit);
pslILEmit->EmitBRFALSE(pNullRefLabel);
// Compare tokens to cover all generic instantiations
// The body of the first method is simply ret Arg0. The second one first casts the arg to I4.
- if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__UNSAFE_CAST_TO_STACKPTR)->GetMemberDef())
- {
- // Return the argument that was passed in converted to IntPtr
- static const BYTE ilcode[] = { CEE_LDARG_0, CEE_CONV_I, CEE_RET };
- methInfo->ILCode = const_cast<BYTE*>(ilcode);
- methInfo->ILCodeSize = sizeof(ilcode);
- methInfo->maxStack = 1;
- methInfo->EHcount = 0;
- methInfo->options = (CorInfoOptions)0;
- return true;
- }
- else if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST)->GetMemberDef())
+ if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__UNSAFE_ENUM_CAST)->GetMemberDef())
{
// Normally we would follow the above pattern and unconditionally replace the IL,
// relying on generic type constraints to guarantee that it will only ever be instantiated
}
else if (tk == MscorlibBinder::GetMethod(METHOD__JIT_HELPERS__GET_RAW_SZ_ARRAY_DATA)->GetMemberDef())
{
- mdToken tokArrayPinningHelper = MscorlibBinder::GetField(FIELD__ARRAY_PINNING_HELPER__M_ARRAY_DATA)->GetMemberDef();
+ mdToken tokRawSzArrayData = MscorlibBinder::GetField(FIELD__RAW_SZARRAY_DATA__DATA)->GetMemberDef();
static BYTE ilcode[] = { CEE_LDARG_0,
CEE_LDFLDA,0,0,0,0,
CEE_RET };
- ilcode[2] = (BYTE)(tokArrayPinningHelper);
- ilcode[3] = (BYTE)(tokArrayPinningHelper >> 8);
- ilcode[4] = (BYTE)(tokArrayPinningHelper >> 16);
- ilcode[5] = (BYTE)(tokArrayPinningHelper >> 24);
+ ilcode[2] = (BYTE)(tokRawSzArrayData);
+ ilcode[3] = (BYTE)(tokRawSzArrayData >> 8);
+ ilcode[4] = (BYTE)(tokRawSzArrayData >> 16);
+ ilcode[5] = (BYTE)(tokRawSzArrayData >> 24);
methInfo->ILCode = const_cast<BYTE*>(ilcode);
methInfo->ILCodeSize = sizeof(ilcode);
#ifdef _DEBUG
DEFINE_METHOD(JIT_HELPERS, UNSAFE_ENUM_CAST, UnsafeEnumCastInternal, NoSig)
DEFINE_METHOD(JIT_HELPERS, UNSAFE_ENUM_CAST_LONG, UnsafeEnumCastLongInternal, NoSig)
-DEFINE_METHOD(JIT_HELPERS, UNSAFE_CAST_TO_STACKPTR,UnsafeCastToStackPointerInternal, NoSig)
#else // _DEBUG
DEFINE_METHOD(JIT_HELPERS, UNSAFE_ENUM_CAST, UnsafeEnumCast, NoSig)
DEFINE_METHOD(JIT_HELPERS, UNSAFE_ENUM_CAST_LONG, UnsafeEnumCastLong, NoSig)
-DEFINE_METHOD(JIT_HELPERS, UNSAFE_CAST_TO_STACKPTR,UnsafeCastToStackPointer, NoSig)
#endif // _DEBUG
DEFINE_METHOD(JIT_HELPERS, GET_RAW_SZ_ARRAY_DATA, GetRawSzArrayData, NoSig)
DEFINE_METHOD(INTERLOCKED, COMPARE_EXCHANGE_T, CompareExchange, GM_RefT_T_T_RetT)
DEFINE_METHOD(INTERLOCKED, COMPARE_EXCHANGE_OBJECT,CompareExchange, SM_RefObject_Object_Object_RetObject)
-DEFINE_CLASS(PINNING_HELPER, CompilerServices, PinningHelper)
-DEFINE_FIELD(PINNING_HELPER, M_DATA, m_data)
+DEFINE_CLASS(RAW_DATA, CompilerServices, RawData)
+DEFINE_FIELD(RAW_DATA, DATA, Data)
-DEFINE_CLASS(ARRAY_PINNING_HELPER, CompilerServices, ArrayPinningHelper)
-DEFINE_FIELD(ARRAY_PINNING_HELPER, M_ARRAY_DATA, m_arrayData)
-DEFINE_FIELD(ARRAY_PINNING_HELPER, M_ARRAY_LENGTH_AND_PADDING, m_lengthAndPadding)
+DEFINE_CLASS(RAW_SZARRAY_DATA, CompilerServices, RawSzArrayData)
+DEFINE_FIELD(RAW_SZARRAY_DATA, COUNT, Count)
+DEFINE_FIELD(RAW_SZARRAY_DATA, DATA, Data)
DEFINE_CLASS(RUNTIME_WRAPPED_EXCEPTION, CompilerServices, RuntimeWrappedException)
DEFINE_METHOD(RUNTIME_WRAPPED_EXCEPTION, OBJ_CTOR, .ctor, IM_Obj_RetVoid)
CreateInstantiatingILStubTargetSig(pTargetMD, typeContext, &stubSigBuilder);
// 2. Emit the method body
- mdToken tokPinningHelper = pCode->GetToken(MscorlibBinder::GetField(FIELD__PINNING_HELPER__M_DATA));
+ mdToken tokRawData = pCode->GetToken(MscorlibBinder::GetField(FIELD__RAW_DATA__DATA));
// 2.1 Push the thisptr
// We need to skip over the MethodTable*
// The trick below will do that.
pCode->EmitLoadThis();
- pCode->EmitLDFLDA(tokPinningHelper);
+ pCode->EmitLDFLDA(tokRawData);
#if defined(_TARGET_X86_)
// 2.2 Push the rest of the arguments for x86
// 2.3 Push the hidden context param
// The context is going to be captured from the thisptr
pCode->EmitLoadThis();
- pCode->EmitLDFLDA(tokPinningHelper);
+ pCode->EmitLDFLDA(tokRawData);
pCode->EmitLDC(Object::GetOffsetOfFirstField());
pCode->EmitSUB();
pCode->EmitLDIND_I();
}
FCIMPLEND
-#ifdef _DEBUG
-FCIMPL1(FC_BOOL_RET, ReflectionInvocation::IsAddressInStack, void * ptr)
-{
- FCALL_CONTRACT;
- FC_RETURN_BOOL(Thread::IsAddressInCurrentStack(ptr));
-}
-FCIMPLEND
-#endif
-
FCIMPL2_IV(Object*, ReflectionInvocation::CreateEnum, ReflectClassBaseObject *pTypeUNSAFE, INT64 value) {
FCALL_CONTRACT;
static FCDECL4(void, MakeTypedReference, TypedByRef * value, Object* targetUNSAFE, ArrayBase* fldsUNSAFE, ReflectClassBaseObject *pFieldType);
static FCDECL2(void, SetTypedReference, TypedByRef * target, Object* objUNSAFE);
static FCDECL1(Object*, TypedReferenceToObject, TypedByRef * value);
-#ifdef _DEBUG
- static FCDECL1(FC_BOOL_RET, IsAddressInStack, void * ptr);
-#endif
#ifdef FEATURE_COMINTEROP
static FCDECL3(Object*, GetClassFromProgID, StringObject* classNameUNSAFE, StringObject* serverUNSAFE, CLR_BOOL bThrowOnError);
projects / platform / upstream / coreclr.git / commitdiff