Rework use of marshalling for RuntimeTypeHandle, RuntimeModule, RuntimeAssembly, and IRuntimeMethodInfo as used by QCalls
- Remove special QCall only used marshallers for RuntimeAssembly, RuntimeModule and IRuntimeMethodInfo
- Following the pattern of ObjectHandleOnStack, implement QCall handle types for RuntimeAssembly/Module/TypeHandle. Use these in all QCalls that once passed the types directly.
- For uses of IRuntimeMethodInfo, follow the existing RuntimeMethodHandleInternal pattern
Also perform some replacement of bool marshalling with use of Interop.BOOL, and a few cases of using pointers instead of byref arguments.
Fix delivers a relatively small win on startup, and small throughput gains around reflection as IL stubs are no longer necessary for many functions in reflection that once needed them.
Reduces methods jitted on powershell startup from 422 to 399, (About 5%) but performance win is only about 5ms on ~400ms as the methods removed are simple.
<PropertyGroup>
<CommonPath>$(MSBuildThisFileDirectory)Common</CommonPath>
<BclSourcesRoot>$(MSBuildThisFileDirectory)src</BclSourcesRoot>
+ <SharedBclSourcesRoot>$(MSBuildThisFileDirectory)shared</SharedBclSourcesRoot>
</PropertyGroup>
<!-- Msbuild variables needed to get CoreCLR features to be set properly. -->
<Compile Include="$(BclSourcesRoot)\System\Variant.cs" />
</ItemGroup>
<ItemGroup Condition="'$(TargetsUnix)' == 'true'">
+ <Compile Include="$(SharedBclSourcesRoot)\Interop\Windows\Interop.BOOL.cs" /> <!-- The CLR internally uses a BOOL type analogous to the Windows BOOL type on Unix -->
<Compile Include="$(BclSourcesRoot)\Interop\Unix\Interop.Libraries.cs" />
<Compile Include="$(BclSourcesRoot)\System\DateTime.Unix.CoreCLR.cs" />
<Compile Include="$(BclSourcesRoot)\System\Globalization\GlobalizationMode.Unix.cs" />
int cchStr);
#if !ENABLE_WINRT
- [DllImport("Kernel32.dll", CharSet = CharSet.Auto)]
- internal static extern bool GetUserPreferredUILanguages(uint dwFlags, out uint pulNumLanguages, char[]? pwszLanguagesBuffer, ref uint pcchLanguagesBuffer);
+ [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
+ internal static extern Interop.BOOL GetUserPreferredUILanguages(uint dwFlags, uint* pulNumLanguages, char* pwszLanguagesBuffer, uint* pcchLanguagesBuffer);
#endif //!ENABLE_WINRT
[DllImport("kernel32.dll", CharSet = CharSet.Unicode)]
return GetCultureByName(strDefault);
}
- private static CultureInfo GetUserDefaultUICulture()
+ private unsafe static CultureInfo GetUserDefaultUICulture()
{
#if !ENABLE_WINRT
if (GlobalizationMode.Invariant)
uint langCount = 0;
uint bufLen = 0;
- if (Interop.Kernel32.GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, out langCount, null, ref bufLen))
+ if (Interop.Kernel32.GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &langCount, null, &bufLen) != Interop.BOOL.FALSE)
{
char[] languages = new char[bufLen];
- if (Interop.Kernel32.GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, out langCount, languages, ref bufLen))
+ fixed (char* pLanguages = languages)
{
- int index = 0;
- while (languages[index] != (char)0 && index < languages.Length)
+ if (Interop.Kernel32.GetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &langCount, pLanguages, &bufLen) != Interop.BOOL.FALSE)
{
- index++;
- }
+ int index = 0;
+ while (languages[index] != (char)0 && index < languages.Length)
+ {
+ index++;
+ }
- return GetCultureByName(new string(languages, 0, index));
+ return GetCultureByName(new string(languages, 0, index));
+ }
}
}
#endif
{
#if FEATURE_APPX
// Cache the value in readonly static that can be optimized out by the JIT
- internal readonly static bool IsUap = IsAppXProcess();
+ internal readonly static bool IsUap = IsAppXProcess() != Interop.BOOL.FALSE;
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern bool IsAppXProcess();
+ private static extern Interop.BOOL IsAppXProcess();
#endif
}
}
public abstract partial class Enum
{
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetEnumValuesAndNames(RuntimeTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, bool getNames);
+ private static extern void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames);
[MethodImpl(MethodImplOptions.InternalCall)]
public override extern bool Equals(object? obj);
{
ulong[]? values = null;
string[]? names = null;
+ RuntimeTypeHandle enumTypeHandle = enumType.GetTypeHandleInternal();
GetEnumValuesAndNames(
- enumType.GetTypeHandleInternal(),
+ JitHelpers.GetQCallTypeHandleOnStack(ref enumTypeHandle),
JitHelpers.GetObjectHandleOnStack(ref values),
JitHelpers.GetObjectHandleOnStack(ref names),
- getNames);
+ getNames ? Interop.BOOL.TRUE : Interop.BOOL.FALSE);
bool hasFlagsAttribute = enumType.IsDefined(typeof(FlagsAttribute), inherit: false);
entry = new EnumInfo(hasFlagsAttribute, values!, names!);
private static class WinRT
{
// Cache the value in readonly static that can be optimized out by the JIT
- public readonly static bool IsSupported = WinRTSupported();
+ public readonly static bool IsSupported = WinRTSupported() != Interop.BOOL.FALSE;
}
// Does the current version of Windows have Windows Runtime suppport?
internal static bool IsWinRTSupported => WinRT.IsSupported;
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- [return: MarshalAs(UnmanagedType.Bool)]
- private static extern bool WinRTSupported();
+ private static extern Interop.BOOL WinRTSupported();
#endif // FEATURE_COMINTEROP
}
}
decoratedModule.ModuleHandle.ResolveTypeHandle(tkParent) :
new RuntimeTypeHandle();
- return RuntimeMethodHandle.IsCAVisibleFromDecoratedType(attributeType.TypeHandle, ctor!, parentTypeHandle, decoratedModule);
+ RuntimeTypeHandle attributeTypeHandle = attributeType.TypeHandle;
+
+ bool result = RuntimeMethodHandle.IsCAVisibleFromDecoratedType(JitHelpers.GetQCallTypeHandleOnStack(ref attributeTypeHandle),
+ ctor != null ? ctor.Value : RuntimeMethodHandleInternal.EmptyHandle,
+ JitHelpers.GetQCallTypeHandleOnStack(ref parentTypeHandle),
+ JitHelpers.GetQCallModuleOnStack(ref decoratedModule)) != Interop.BOOL.FALSE;
+
+ GC.KeepAlive(ctor);
+ return result;
}
#endregion
{
// Compile the method since accessibility checks are done as part of compilation.
GetMethodDescriptor();
- System.Runtime.CompilerServices.RuntimeHelpers._CompileMethod(m_methodHandle!);
+ IRuntimeMethodInfo? methodHandle = m_methodHandle;
+ System.Runtime.CompilerServices.RuntimeHelpers._CompileMethod(methodHandle != null ? methodHandle.Value : RuntimeMethodHandleInternal.EmptyHandle);
+ GC.KeepAlive(methodHandle);
}
MulticastDelegate d = (MulticastDelegate)Delegate.CreateDelegateNoSecurityCheck(delegateType, null, GetMethodDescriptor());
{
// Compile the method since accessibility checks are done as part of compilation
GetMethodDescriptor();
- System.Runtime.CompilerServices.RuntimeHelpers._CompileMethod(m_methodHandle!);
+ IRuntimeMethodInfo? methodHandle = m_methodHandle;
+ System.Runtime.CompilerServices.RuntimeHelpers._CompileMethod(methodHandle != null ? methodHandle.Value : RuntimeMethodHandleInternal.EmptyHandle);
+ GC.KeepAlive(methodHandle);
}
MulticastDelegate d = (MulticastDelegate)Delegate.CreateDelegateNoSecurityCheck(delegateType, target, GetMethodDescriptor());
**
===========================================================*/
+using System.Runtime.CompilerServices;
+
namespace System.Reflection.Emit
{
//
}
m_type.ThrowIfCreated();
+ ModuleBuilder module = m_module;
TypeBuilder.DefineMethodSemantics(
- m_module.GetNativeHandle(),
+ JitHelpers.GetQCallModuleOnStack(ref module),
m_evToken.Token,
semantics,
mdBuilder.GetToken().Token);
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+using System.Runtime.CompilerServices;
using CultureInfo = System.Globalization.CultureInfo;
namespace System.Reflection.Emit
int sigLength;
byte[] signature = sigHelp.InternalGetSignature(out sigLength);
- m_fieldTok = TypeBuilder.DefineField(m_typeBuilder.GetModuleBuilder().GetNativeHandle(),
+ ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
+ m_fieldTok = TypeBuilder.DefineField(JitHelpers.GetQCallModuleOnStack(ref module),
typeBuilder.TypeToken.Token, fieldName, signature, sigLength, m_Attributes);
m_tkField = new FieldToken(m_fieldTok, type);
#region Internal Members
internal void SetData(byte[]? data, int size)
{
- ModuleBuilder.SetFieldRVAContent(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), m_tkField.Token, data, size);
+ ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
+ ModuleBuilder.SetFieldRVAContent(JitHelpers.GetQCallModuleOnStack(ref module), m_tkField.Token, data, size);
}
#endregion
{
m_typeBuilder.ThrowIfCreated();
- TypeBuilder.SetFieldLayoutOffset(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, iOffset);
+ ModuleBuilder module = m_typeBuilder.GetModuleBuilder();
+ TypeBuilder.SetFieldLayoutOffset(JitHelpers.GetQCallModuleOnStack(ref module), GetToken().Token, iOffset);
}
public void SetConstant(object? defaultValue)
using CultureInfo = System.Globalization.CultureInfo;
using System.Diagnostics.SymbolStore;
using System.Collections.Generic;
+using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Diagnostics;
int sigLength;
byte[] sigBytes = GetMethodSignature().InternalGetSignature(out sigLength);
+ ModuleBuilder module = m_module;
- int token = TypeBuilder.DefineMethod(m_module.GetNativeHandle(), m_containingType.MetadataTokenInternal, m_strName, sigBytes, sigLength, Attributes);
+ int token = TypeBuilder.DefineMethod(JitHelpers.GetQCallModuleOnStack(ref module), m_containingType.MetadataTokenInternal, m_strName, sigBytes, sigLength, Attributes);
m_tkMethod = new MethodToken(token);
if (m_inst != null)
foreach (GenericTypeParameterBuilder tb in m_inst)
if (!tb.m_type.IsCreated()) tb.m_type.CreateType();
- TypeBuilder.SetMethodImpl(m_module.GetNativeHandle(), token, m_dwMethodImplFlags);
+ TypeBuilder.SetMethodImpl(JitHelpers.GetQCallModuleOnStack(ref module), token, m_dwMethodImplFlags);
return m_tkMethod;
}
m_canBeRuntimeImpl = true;
- TypeBuilder.SetMethodImpl(m_module.GetNativeHandle(), MetadataTokenInternal, attributes);
+ ModuleBuilder module = m_module;
+ TypeBuilder.SetMethodImpl(JitHelpers.GetQCallModuleOnStack(ref module), MetadataTokenInternal, attributes);
}
public ILGenerator GetILGenerator()
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetTypeRef(RuntimeModule module, string strFullName, RuntimeModule refedModule, string? strRefedModuleFileName, int tkResolution);
+ private static extern int GetTypeRef(QCallModule module, string strFullName, QCallModule refedModule, string? strRefedModuleFileName, int tkResolution);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetMemberRef(RuntimeModule module, RuntimeModule refedModule, int tr, int defToken);
+ private static extern int GetMemberRef(QCallModule module, QCallModule refedModule, int tr, int defToken);
private int GetMemberRef(Module? refedModule, int tr, int defToken)
{
- return GetMemberRef(GetNativeHandle(), GetRuntimeModuleFromModule(refedModule).GetNativeHandle(), tr, defToken);
+ ModuleBuilder thisModule = this;
+ RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule);
+
+ return GetMemberRef(JitHelpers.GetQCallModuleOnStack(ref thisModule), JitHelpers.GetQCallModuleOnStack(ref refedRuntimeModule), tr, defToken);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetMemberRefFromSignature(RuntimeModule module, int tr, string methodName, byte[] signature, int length);
+ private static extern int GetMemberRefFromSignature(QCallModule module, int tr, string methodName, byte[] signature, int length);
private int GetMemberRefFromSignature(int tr, string methodName, byte[] signature, int length)
{
- return GetMemberRefFromSignature(GetNativeHandle(), tr, methodName, signature, length);
+ ModuleBuilder thisModule = this;
+ return GetMemberRefFromSignature(JitHelpers.GetQCallModuleOnStack(ref thisModule), tr, methodName, signature, length);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetMemberRefOfMethodInfo(RuntimeModule module, int tr, IRuntimeMethodInfo method);
+ private static extern int GetMemberRefOfMethodInfo(QCallModule module, int tr, RuntimeMethodHandleInternal method);
private int GetMemberRefOfMethodInfo(int tr, RuntimeMethodInfo method)
{
Debug.Assert(method != null);
- return GetMemberRefOfMethodInfo(GetNativeHandle(), tr, method);
+ ModuleBuilder thisModule = this;
+ int result = GetMemberRefOfMethodInfo(JitHelpers.GetQCallModuleOnStack(ref thisModule), tr, ((IRuntimeMethodInfo)method).Value);
+ GC.KeepAlive(method);
+ return result;
}
private int GetMemberRefOfMethodInfo(int tr, RuntimeConstructorInfo method)
{
Debug.Assert(method != null);
- return GetMemberRefOfMethodInfo(GetNativeHandle(), tr, method);
+ ModuleBuilder thisModule = this;
+ int result = GetMemberRefOfMethodInfo(JitHelpers.GetQCallModuleOnStack(ref thisModule), tr, ((IRuntimeMethodInfo)method).Value);
+ GC.KeepAlive(method);
+ return result;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetMemberRefOfFieldInfo(RuntimeModule module, int tkType, RuntimeTypeHandle declaringType, int tkField);
+ private static extern int GetMemberRefOfFieldInfo(QCallModule module, int tkType, QCallTypeHandle declaringType, int tkField);
private int GetMemberRefOfFieldInfo(int tkType, RuntimeTypeHandle declaringType, RuntimeFieldInfo runtimeField)
{
Debug.Assert(runtimeField != null);
- return GetMemberRefOfFieldInfo(GetNativeHandle(), tkType, declaringType, runtimeField.MetadataToken);
+ ModuleBuilder thisModule = this;
+ return GetMemberRefOfFieldInfo(JitHelpers.GetQCallModuleOnStack(ref thisModule), tkType, JitHelpers.GetQCallTypeHandleOnStack(ref declaringType), runtimeField.MetadataToken);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetTokenFromTypeSpec(RuntimeModule pModule, byte[] signature, int length);
+ private static extern int GetTokenFromTypeSpec(QCallModule pModule, byte[] signature, int length);
private int GetTokenFromTypeSpec(byte[] signature, int length)
{
- return GetTokenFromTypeSpec(GetNativeHandle(), signature, length);
+ ModuleBuilder thisModule = this;
+ return GetTokenFromTypeSpec(JitHelpers.GetQCallModuleOnStack(ref thisModule), signature, length);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetArrayMethodToken(RuntimeModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength);
+ private static extern int GetArrayMethodToken(QCallModule module, int tkTypeSpec, string methodName, byte[] signature, int sigLength);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetStringConstant(RuntimeModule module, string str, int length);
+ private static extern int GetStringConstant(QCallModule module, string str, int length);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void SetFieldRVAContent(RuntimeModule module, int fdToken, byte[]? data, int length);
+ internal static extern void SetFieldRVAContent(QCallModule module, int fdToken, byte[]? data, int length);
#endregion
Debug.Assert(!type.IsByRef, "Must not be ByRef.");
Debug.Assert(!type.IsGenericType || type.IsGenericTypeDefinition, "Must not have generic arguments.");
- return GetTypeRef(GetNativeHandle(), typeName, GetRuntimeModuleFromModule(refedModule).GetNativeHandle(), strRefedModuleFileName, tkResolution);
+ ModuleBuilder thisModule = this;
+ RuntimeModule refedRuntimeModule = GetRuntimeModuleFromModule(refedModule);
+ return GetTypeRef(JitHelpers.GetQCallModuleOnStack(ref thisModule), typeName, JitHelpers.GetQCallModuleOnStack(ref refedRuntimeModule), strRefedModuleFileName, tkResolution);
}
internal MethodToken InternalGetConstructorToken(ConstructorInfo con, bool usingRef)
// Create MethodSepc M<Bar> with parent G?.M<S>
byte[] sigBytes = SignatureHelper.GetMethodSpecSigHelper(
this, methodInfo.GetGenericArguments()).InternalGetSignature(out int sigLength);
- tk = TypeBuilder.DefineMethodSpec(GetNativeHandle(), tk, sigBytes, sigLength);
+ ModuleBuilder thisModule = this;
+ tk = TypeBuilder.DefineMethodSpec(JitHelpers.GetQCallModuleOnStack(ref thisModule), tk, sigBytes, sigLength);
}
else
{
byte[] sigBytes = sigHelp.InternalGetSignature(out int length);
TypeToken typeSpec = GetTypeTokenInternal(arrayClass);
- return new MethodToken(GetArrayMethodToken(GetNativeHandle(),
+ ModuleBuilder thisModule = this;
+ return new MethodToken(GetArrayMethodToken(JitHelpers.GetQCallModuleOnStack(ref thisModule),
typeSpec.Token, methodName, sigBytes, length));
}
// Returns a token representing a String constant. If the string
// value has already been defined, the existing token will be returned.
- return new StringToken(GetStringConstant(GetNativeHandle(), str, str.Length));
+ ModuleBuilder thisModule = this;
+ return new StringToken(GetStringConstant(JitHelpers.GetQCallModuleOnStack(ref thisModule), str, str.Length));
}
public SignatureToken GetSignatureToken(SignatureHelper sigHelper)
// get the signature in byte form
byte[] sigBytes = sigHelper.InternalGetSignature(out int sigLength);
- return new SignatureToken(TypeBuilder.GetTokenFromSig(GetNativeHandle(), sigBytes, sigLength));
+ ModuleBuilder thisModule = this;
+ return new SignatureToken(TypeBuilder.GetTokenFromSig(JitHelpers.GetQCallModuleOnStack(ref thisModule), sigBytes, sigLength));
}
public SignatureToken GetSignatureToken(byte[] sigBytes, int sigLength)
byte[] localSigBytes = new byte[sigBytes.Length];
Buffer.BlockCopy(sigBytes, 0, localSigBytes, 0, sigBytes.Length);
- return new SignatureToken(TypeBuilder.GetTokenFromSig(GetNativeHandle(), localSigBytes, sigLength));
+ ModuleBuilder thisModule = this;
+ return new SignatureToken(TypeBuilder.GetTokenFromSig(JitHelpers.GetQCallModuleOnStack(ref thisModule), localSigBytes, sigLength));
}
#endregion
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
+using System.Runtime.CompilerServices;
+
namespace System.Reflection.Emit
{
public class ParameterBuilder
_name = paramName;
_methodBuilder = methodBuilder;
_attributes = attributes;
+ ModuleBuilder module = _methodBuilder.GetModuleBuilder();
_token = new ParameterToken(TypeBuilder.SetParamInfo(
- _methodBuilder.GetModuleBuilder().GetNativeHandle(),
+ JitHelpers.GetQCallModuleOnStack(ref module),
_methodBuilder.GetToken().Token,
sequence,
attributes,
**
===========================================================*/
+using System.Runtime.CompilerServices;
using CultureInfo = System.Globalization.CultureInfo;
namespace System.Reflection.Emit
}
m_containingType.ThrowIfCreated();
+ ModuleBuilder module = m_moduleBuilder;
TypeBuilder.DefineMethodSemantics(
- m_moduleBuilder.GetNativeHandle(),
+ JitHelpers.GetQCallModuleOnStack(ref module),
m_prToken.Token,
semantics,
mdBuilder.GetToken().Token);
#region Private Static FCalls
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void SetParentType(RuntimeModule module, int tdTypeDef, int tkParent);
+ private static extern void SetParentType(QCallModule module, int tdTypeDef, int tkParent);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void AddInterfaceImpl(RuntimeModule module, int tdTypeDef, int tkInterface);
+ private static extern void AddInterfaceImpl(QCallModule module, int tdTypeDef, int tkInterface);
#endregion
#region Internal Static FCalls
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int DefineMethod(RuntimeModule module, int tkParent, string name, byte[] signature, int sigLength,
+ internal static extern int DefineMethod(QCallModule module, int tkParent, string name, byte[] signature, int sigLength,
MethodAttributes attributes);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int DefineMethodSpec(RuntimeModule module, int tkParent, byte[] signature, int sigLength);
+ internal static extern int DefineMethodSpec(QCallModule module, int tkParent, byte[] signature, int sigLength);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int DefineField(RuntimeModule module, int tkParent, string name, byte[] signature, int sigLength,
+ internal static extern int DefineField(QCallModule module, int tkParent, string name, byte[] signature, int sigLength,
FieldAttributes attributes);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void SetMethodIL(RuntimeModule module, int tk, bool isInitLocals,
+ private static extern void SetMethodIL(QCallModule module, int tk, bool isInitLocals,
byte[]? body, int bodyLength,
byte[] LocalSig, int sigLength,
int maxStackSize,
int[]? tokenFixups, int numTokenFixups);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void DefineCustomAttribute(RuntimeModule module, int tkAssociate, int tkConstructor,
+ private static extern void DefineCustomAttribute(QCallModule module, int tkAssociate, int tkConstructor,
byte[]? attr, int attrLength, bool toDisk, bool updateCompilerFlags);
internal static void DefineCustomAttribute(ModuleBuilder module, int tkAssociate, int tkConstructor,
Buffer.BlockCopy(attr, 0, localAttr, 0, attr.Length);
}
- DefineCustomAttribute(module.GetNativeHandle(), tkAssociate, tkConstructor,
+ DefineCustomAttribute(JitHelpers.GetQCallModuleOnStack(ref module), tkAssociate, tkConstructor,
localAttr, (localAttr != null) ? localAttr.Length : 0, toDisk, updateCompilerFlags);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int DefineProperty(RuntimeModule module, int tkParent, string name, PropertyAttributes attributes,
+ internal static extern int DefineProperty(QCallModule module, int tkParent, string name, PropertyAttributes attributes,
byte[] signature, int sigLength);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int DefineEvent(RuntimeModule module, int tkParent, string name, EventAttributes attributes, int tkEventType);
+ internal static extern int DefineEvent(QCallModule module, int tkParent, string name, EventAttributes attributes, int tkEventType);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void DefineMethodSemantics(RuntimeModule module, int tkAssociation,
+ internal static extern void DefineMethodSemantics(QCallModule module, int tkAssociation,
MethodSemanticsAttributes semantics, int tkMethod);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void DefineMethodImpl(RuntimeModule module, int tkType, int tkBody, int tkDecl);
+ internal static extern void DefineMethodImpl(QCallModule module, int tkType, int tkBody, int tkDecl);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void SetMethodImpl(RuntimeModule module, int tkMethod, MethodImplAttributes MethodImplAttributes);
+ internal static extern void SetMethodImpl(QCallModule module, int tkMethod, MethodImplAttributes MethodImplAttributes);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int SetParamInfo(RuntimeModule module, int tkMethod, int iSequence,
+ internal static extern int SetParamInfo(QCallModule module, int tkMethod, int iSequence,
ParameterAttributes iParamAttributes, string? strParamName);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern int GetTokenFromSig(RuntimeModule module, byte[] signature, int sigLength);
+ internal static extern int GetTokenFromSig(QCallModule module, byte[] signature, int sigLength);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void SetFieldLayoutOffset(RuntimeModule module, int fdToken, int iOffset);
+ internal static extern void SetFieldLayoutOffset(QCallModule module, int fdToken, int iOffset);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void SetClassLayout(RuntimeModule module, int tk, PackingSize iPackingSize, int iTypeSize);
+ internal static extern void SetClassLayout(QCallModule module, int tk, PackingSize iPackingSize, int iTypeSize);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern unsafe void SetConstantValue(RuntimeModule module, int tk, int corType, void* pValue);
+ private static extern unsafe void SetConstantValue(QCallModule module, int tk, int corType, void* pValue);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void SetPInvokeData(RuntimeModule module, string DllName, string name, int token, int linkFlags);
+ private static extern void SetPInvokeData(QCallModule module, string DllName, string name, int token, int linkFlags);
#endregion
#region Internal\Private Static Members
case CorElementType.ELEMENT_TYPE_U8:
case CorElementType.ELEMENT_TYPE_R8:
fixed (byte* pData = &value.GetRawData())
- SetConstantValue(module.GetNativeHandle(), tk, (int)corType, pData);
+ SetConstantValue(JitHelpers.GetQCallModuleOnStack(ref module), tk, (int)corType, pData);
break;
default:
if (type == typeof(string))
{
fixed (char* pString = (string)value)
- SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString);
+ SetConstantValue(JitHelpers.GetQCallModuleOnStack(ref module), tk, (int)CorElementType.ELEMENT_TYPE_STRING, pString);
}
else if (type == typeof(DateTime))
{
//date is a I8 representation
long ticks = ((DateTime)value).Ticks;
- SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks);
+ SetConstantValue(JitHelpers.GetQCallModuleOnStack(ref module), tk, (int)CorElementType.ELEMENT_TYPE_I8, &ticks);
}
else
{
// (See ECMA-335 II.15.4.1.4 "The .param directive" and II.22.9 "Constant" for details.)
// This is how the Roslyn compilers generally encode `default(TValueType)` default values.
- SetConstantValue(module.GetNativeHandle(), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null);
+ SetConstantValue(JitHelpers.GetQCallModuleOnStack(ref module), tk, (int)CorElementType.ELEMENT_TYPE_CLASS, null);
}
}
tkEnclosingType = enclosingType.m_tdType.Token;
}
- m_tdType = new TypeToken(DefineType(m_module.GetNativeHandle(),
+ m_tdType = new TypeToken(DefineType(JitHelpers.GetQCallModuleOnStack(ref module),
fullname, tkParent, m_iAttr, tkEnclosingType, interfaceTokens!));
m_iPackingSize = iPackingSize;
m_iTypeSize = iTypeSize;
if ((m_iPackingSize != 0) || (m_iTypeSize != 0))
- SetClassLayout(GetModuleBuilder().GetNativeHandle(), m_tdType.Token, m_iPackingSize, m_iTypeSize);
+ SetClassLayout(JitHelpers.GetQCallModuleOnStack(ref module), m_tdType.Token, m_iPackingSize, m_iTypeSize);
m_module.AddType(FullName!, this);
}
#region FCalls
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int DefineType(RuntimeModule module,
+ private static extern int DefineType(QCallModule module,
string fullname, int tkParent, TypeAttributes attributes, int tkEnclosingType, int[] interfaceTokens);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int DefineGenericParam(RuntimeModule module,
+ private static extern int DefineGenericParam(QCallModule module,
string name, int tkParent, GenericParameterAttributes attributes, int position, int[] constraints);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void TermCreateClass(RuntimeModule module, int tk, ObjectHandleOnStack type);
+ private static extern void TermCreateClass(QCallModule module, int tk, ObjectHandleOnStack type);
#endregion
#region Internal Methods
MethodToken tkBody = m_module.GetMethodTokenInternal(methodInfoBody);
MethodToken tkDecl = m_module.GetMethodTokenInternal(methodInfoDeclaration);
- DefineMethodImpl(m_module.GetNativeHandle(), m_tdType.Token, tkBody.Token, tkDecl.Token);
+ ModuleBuilder module = m_module;
+ DefineMethodImpl(JitHelpers.GetQCallModuleOnStack(ref module), m_tdType.Token, tkBody.Token, tkDecl.Token);
}
public MethodBuilder DefineMethod(string name, MethodAttributes attributes, Type? returnType, Type[]? parameterTypes)
break;
}
- SetPInvokeData(m_module.GetNativeHandle(),
+ ModuleBuilder module = m_module;
+ SetPInvokeData(JitHelpers.GetQCallModuleOnStack(ref module),
dllName,
importName,
token.Token,
// get the signature in byte form
sigBytes = sigHelper.InternalGetSignature(out sigLength);
+ ModuleBuilder module = m_module;
+
PropertyToken prToken = new PropertyToken(DefineProperty(
- m_module.GetNativeHandle(),
+ JitHelpers.GetQCallModuleOnStack(ref module),
m_tdType.Token,
name,
attributes,
tkType = m_module.GetTypeTokenInternal(eventtype).Token;
// Internal helpers to define property records
+ ModuleBuilder module = m_module;
evToken = new EventToken(DefineEvent(
- m_module.GetNativeHandle(),
+ JitHelpers.GetQCallModuleOnStack(ref module),
m_tdType.Token,
name,
attributes,
if (m_typeParent != null)
tkParent = m_module.GetTypeTokenInternal(m_typeParent).Token;
+ ModuleBuilder module = m_module;
+
if (IsGenericParameter)
{
int[] constraints; // Array of token constrains terminated by null token
}
int declMember = m_declMeth == null ? m_DeclaringType!.m_tdType.Token : m_declMeth.GetToken().Token;
- m_tdType = new TypeToken(DefineGenericParam(m_module.GetNativeHandle(),
+ m_tdType = new TypeToken(DefineGenericParam(JitHelpers.GetQCallModuleOnStack(ref module),
m_strName!, declMember, m_genParamAttributes, m_genParamPos, constraints));
if (m_ca != null)
// Check for global typebuilder
if (((m_tdType.Token & 0x00FFFFFF) != 0) && ((tkParent & 0x00FFFFFF) != 0))
{
- SetParentType(m_module.GetNativeHandle(), m_tdType.Token, tkParent);
+ SetParentType(JitHelpers.GetQCallModuleOnStack(ref module), m_tdType.Token, tkParent);
}
if (m_inst != null)
ExceptionHandler[]? exceptions = meth.GetExceptionHandlers();
int[]? tokenFixups = meth.GetTokenFixups();
- SetMethodIL(m_module.GetNativeHandle(), meth.GetToken().Token, meth.InitLocals,
+ SetMethodIL(JitHelpers.GetQCallModuleOnStack(ref module), meth.GetToken().Token, meth.InitLocals,
body, (body != null) ? body.Length : 0,
localSig, sigLength, maxStack,
exceptions, (exceptions != null) ? exceptions.Length : 0,
// Terminate the process.
RuntimeType cls = null!;
- TermCreateClass(m_module.GetNativeHandle(), m_tdType.Token, JitHelpers.GetObjectHandleOnStack(ref cls));
+ TermCreateClass(JitHelpers.GetQCallModuleOnStack(ref module), m_tdType.Token, JitHelpers.GetObjectHandleOnStack(ref cls));
if (!m_isHiddenGlobalType)
{
ThrowIfCreated();
TypeToken tkInterface = m_module.GetTypeTokenInternal(interfaceType);
- AddInterfaceImpl(m_module.GetNativeHandle(), m_tdType.Token, tkInterface.Token);
+ ModuleBuilder module = m_module;
+ AddInterfaceImpl(JitHelpers.GetQCallModuleOnStack(ref module), m_tdType.Token, tkInterface.Token);
m_typeInterfaces.Add(interfaceType);
}
{
[DllImport(JitHelpers.QCall)]
[return: MarshalAs(UnmanagedType.Bool)]
- private static extern unsafe bool InternalTryGetRawMetadata(RuntimeAssembly assembly, ref byte* blob, ref int length);
+ private static extern unsafe bool InternalTryGetRawMetadata(QCallAssembly assembly, ref byte* blob, ref int length);
// Retrieves the metadata section of the assembly, for use with System.Reflection.Metadata.MetadataReader.
// - Returns false upon failure. Metadata might not be available for some assemblies, such as AssemblyBuilder, .NET
return false;
}
- return InternalTryGetRawMetadata(runtimeAssembly, ref blob, ref length);
+ RuntimeAssembly rtAsm = runtimeAssembly;
+
+ return InternalTryGetRawMetadata(JitHelpers.GetQCallAssemblyOnStack(ref rtAsm), ref blob, ref length);
}
}
}
#endregion
+ internal IntPtr GetUnderlyingNativeHandle() { return m_assembly; }
+
private sealed class ManifestResourceStream : UnmanagedMemoryStream
{
private RuntimeAssembly _manifestAssembly;
private const string s_localFilePrefix = "file:";
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetCodeBase(RuntimeAssembly assembly,
+ private static extern void GetCodeBase(QCallAssembly assembly,
bool copiedName,
StringHandleOnStack retString);
internal string? GetCodeBase(bool copiedName)
{
string? codeBase = null;
- GetCodeBase(GetNativeHandle(), copiedName, JitHelpers.GetStringHandleOnStack(ref codeBase));
+ RuntimeAssembly runtimeAssembly = this;
+ GetCodeBase(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), copiedName, JitHelpers.GetStringHandleOnStack(ref codeBase));
return codeBase;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetFullName(RuntimeAssembly assembly, StringHandleOnStack retString);
+ private static extern void GetFullName(QCallAssembly assembly, StringHandleOnStack retString);
public override string? FullName
{
if (m_fullname == null)
{
string? s = null;
- GetFullName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s));
+ RuntimeAssembly runtimeAssembly = this;
+ GetFullName(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetStringHandleOnStack(ref s));
Interlocked.CompareExchange(ref m_fullname, s, null);
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetEntryPoint(RuntimeAssembly assembly, ObjectHandleOnStack retMethod);
+ private static extern void GetEntryPoint(QCallAssembly assembly, ObjectHandleOnStack retMethod);
public override MethodInfo? EntryPoint
{
get
{
IRuntimeMethodInfo? methodHandle = null;
- GetEntryPoint(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref methodHandle));
+ RuntimeAssembly runtimeAssembly = this;
+ GetEntryPoint(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetObjectHandleOnStack(ref methodHandle));
if (methodHandle == null)
return null;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetType(RuntimeAssembly assembly,
+ private static extern void GetType(QCallAssembly assembly,
string name,
bool throwOnError,
bool ignoreCase,
object? keepAlive = null;
AssemblyLoadContext? assemblyLoadContextStack = AssemblyLoadContext.CurrentContextualReflectionContext;
- GetType(GetNativeHandle(),
+ RuntimeAssembly runtimeAssembly = this;
+ GetType(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly),
name,
throwOnError,
ignoreCase,
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetExportedTypes(RuntimeAssembly assembly, ObjectHandleOnStack retTypes);
+ private static extern void GetExportedTypes(QCallAssembly assembly, ObjectHandleOnStack retTypes);
public override Type[] GetExportedTypes()
{
Type[]? types = null;
- GetExportedTypes(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));
+ RuntimeAssembly runtimeAssembly = this;
+ GetExportedTypes(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetObjectHandleOnStack(ref types));
return types!;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- [return: MarshalAs(UnmanagedType.Bool)]
- internal static extern bool GetIsCollectible(RuntimeAssembly assembly);
+ internal static extern Interop.BOOL GetIsCollectible(QCallAssembly assembly);
- public override bool IsCollectible => GetIsCollectible(GetNativeHandle());
+ public override bool IsCollectible
+ {
+ get
+ {
+ RuntimeAssembly runtimeAssembly = this;
+ return GetIsCollectible(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly)) != Interop.BOOL.FALSE;
+ }
+ }
// GetResource will return a pointer to the resources in memory.
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern unsafe byte* GetResource(RuntimeAssembly assembly,
+ private static extern unsafe byte* GetResource(QCallAssembly assembly,
string resourceName,
out uint length);
public unsafe override Stream? GetManifestResourceStream(string name)
{
uint length = 0;
- byte* pbInMemoryResource = GetResource(GetNativeHandle(), name, out length);
+ RuntimeAssembly runtimeAssembly = this;
+ byte* pbInMemoryResource = GetResource(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), name, out length);
if (pbInMemoryResource != null)
{
// Returns the module in this assembly with name 'name'
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetModule(RuntimeAssembly assembly, string name, ObjectHandleOnStack retModule);
+ private static extern void GetModule(QCallAssembly assembly, string name, ObjectHandleOnStack retModule);
public override Module? GetModule(string name)
{
Module? retModule = null;
- GetModule(GetNativeHandle(), name, JitHelpers.GetObjectHandleOnStack(ref retModule));
+ RuntimeAssembly runtimeAssembly = this;
+ GetModule(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), name, JitHelpers.GetObjectHandleOnStack(ref retModule));
return retModule;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern int GetManifestResourceInfo(RuntimeAssembly assembly,
+ private static extern int GetManifestResourceInfo(QCallAssembly assembly,
string resourceName,
ObjectHandleOnStack assemblyRef,
StringHandleOnStack retFileName);
{
RuntimeAssembly? retAssembly = null;
string? fileName = null;
- int location = GetManifestResourceInfo(GetNativeHandle(), resourceName,
+ RuntimeAssembly runtimeAssembly = this;
+ int location = GetManifestResourceInfo(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), resourceName,
JitHelpers.GetObjectHandleOnStack(ref retAssembly),
JitHelpers.GetStringHandleOnStack(ref fileName));
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetLocation(RuntimeAssembly assembly, StringHandleOnStack retString);
+ private static extern void GetLocation(QCallAssembly assembly, StringHandleOnStack retString);
public override string Location
{
{
string? location = null;
- GetLocation(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref location));
+ RuntimeAssembly runtimeAssembly = this;
+ GetLocation(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetStringHandleOnStack(ref location));
return location!;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetImageRuntimeVersion(RuntimeAssembly assembly, StringHandleOnStack retString);
+ private static extern void GetImageRuntimeVersion(QCallAssembly assembly, StringHandleOnStack retString);
public override string ImageRuntimeVersion
{
get
{
string? s = null;
- GetImageRuntimeVersion(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref s));
+ RuntimeAssembly runtimeAssembly = this;
+ GetImageRuntimeVersion(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetStringHandleOnStack(ref s));
return s!;
}
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetVersion(RuntimeAssembly assembly,
+ private static extern void GetVersion(QCallAssembly assembly,
out int majVer,
out int minVer,
out int buildNum,
internal Version GetVersion()
{
int majorVer, minorVer, build, revision;
- GetVersion(GetNativeHandle(), out majorVer, out minorVer, out build, out revision);
+ RuntimeAssembly runtimeAssembly = this;
+ GetVersion(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), out majorVer, out minorVer, out build, out revision);
return new Version(majorVer, minorVer, build, revision);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetLocale(RuntimeAssembly assembly, StringHandleOnStack retString);
+ private static extern void GetLocale(QCallAssembly assembly, StringHandleOnStack retString);
internal CultureInfo GetLocale()
{
string? locale = null;
- GetLocale(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref locale));
+ RuntimeAssembly runtimeAssembly = this;
+ GetLocale(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetStringHandleOnStack(ref locale));
if (locale == null)
return CultureInfo.InvariantCulture;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetSimpleName(RuntimeAssembly assembly, StringHandleOnStack retSimpleName);
+ private static extern void GetSimpleName(QCallAssembly assembly, StringHandleOnStack retSimpleName);
internal string? GetSimpleName()
{
+ RuntimeAssembly runtimeAssembly = this;
string? name = null;
- GetSimpleName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref name));
+ GetSimpleName(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetStringHandleOnStack(ref name));
return name;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern AssemblyHashAlgorithm GetHashAlgorithm(RuntimeAssembly assembly);
+ private static extern AssemblyHashAlgorithm GetHashAlgorithm(QCallAssembly assembly);
private AssemblyHashAlgorithm GetHashAlgorithm()
{
- return GetHashAlgorithm(GetNativeHandle());
+ RuntimeAssembly runtimeAssembly = this;
+ return GetHashAlgorithm(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly));
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern AssemblyNameFlags GetFlags(RuntimeAssembly assembly);
+ private static extern AssemblyNameFlags GetFlags(QCallAssembly assembly);
private AssemblyNameFlags GetFlags()
{
- return GetFlags(GetNativeHandle());
+ RuntimeAssembly runtimeAssembly = this;
+ return GetFlags(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly));
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetPublicKey(RuntimeAssembly assembly, ObjectHandleOnStack retPublicKey);
+ private static extern void GetPublicKey(QCallAssembly assembly, ObjectHandleOnStack retPublicKey);
internal byte[]? GetPublicKey()
{
byte[]? publicKey = null;
- GetPublicKey(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref publicKey));
+ RuntimeAssembly runtimeAssembly = this;
+ GetPublicKey(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), JitHelpers.GetObjectHandleOnStack(ref publicKey));
return publicKey;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetModules(RuntimeAssembly assembly,
+ private static extern void GetModules(QCallAssembly assembly,
bool loadIfNotFound,
bool getResourceModules,
ObjectHandleOnStack retModuleHandles);
bool getResourceModules)
{
RuntimeModule[]? modules = null;
- GetModules(GetNativeHandle(), loadIfNotFound, getResourceModules, JitHelpers.GetObjectHandleOnStack(ref modules));
+ RuntimeAssembly runtimeAssembly = this;
+
+ GetModules(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly), loadIfNotFound, getResourceModules, JitHelpers.GetObjectHandleOnStack(ref modules));
return modules!;
}
MetadataImport scope = GetManifestModule(GetNativeHandle()).MetadataImport;
scope.Enum(MetadataTokenType.ExportedType, 0, out MetadataEnumResult enumResult);
+ RuntimeAssembly runtimeAssembly = this;
+ QCallAssembly pAssembly = JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly);
for (int i = 0; i < enumResult.Length; i++)
{
MetadataToken mdtExternalType = enumResult[i];
ObjectHandleOnStack pType = JitHelpers.GetObjectHandleOnStack(ref type);
try
{
- GetForwardedType(this, mdtExternalType, pType);
+ GetForwardedType(pAssembly, mdtExternalType, pType);
if (type == null)
continue; // mdtExternalType was not a forwarder entry.
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetForwardedType(RuntimeAssembly assembly, MetadataToken mdtExternalType, ObjectHandleOnStack type);
+ private static extern void GetForwardedType(QCallAssembly assembly, MetadataToken mdtExternalType, ObjectHandleOnStack type);
}
}
}
#pragma warning restore CS8608
- public override bool IsCollectible => RuntimeMethodHandle.GetIsCollectible(new RuntimeMethodHandleInternal(m_handle));
+ public override bool IsCollectible => (RuntimeMethodHandle.GetIsCollectible(new RuntimeMethodHandleInternal(m_handle)) != Interop.BOOL.FALSE);
public override MethodInfo? GetBaseDefinition()
{
#region FCalls
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetType(RuntimeModule module, string className, bool throwOnError, bool ignoreCase, ObjectHandleOnStack type, ObjectHandleOnStack keepAlive);
+ private static extern void GetType(QCallModule module, string className, bool throwOnError, bool ignoreCase, ObjectHandleOnStack type, ObjectHandleOnStack keepAlive);
[DllImport(JitHelpers.QCall)]
- private static extern bool nIsTransientInternal(RuntimeModule module);
+ private static extern bool nIsTransientInternal(QCallModule module);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetScopeName(RuntimeModule module, StringHandleOnStack retString);
+ private static extern void GetScopeName(QCallModule module, StringHandleOnStack retString);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetFullyQualifiedName(RuntimeModule module, StringHandleOnStack retString);
+ private static extern void GetFullyQualifiedName(QCallModule module, StringHandleOnStack retString);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern RuntimeType[] GetTypes(RuntimeModule module);
get
{
if (m_runtimeType == null)
- m_runtimeType = ModuleHandle.GetModuleType(GetNativeHandle());
+ m_runtimeType = ModuleHandle.GetModuleType(this);
return m_runtimeType;
}
internal bool IsTransientInternal()
{
- return RuntimeModule.nIsTransientInternal(this.GetNativeHandle());
+ RuntimeModule thisAsLocal = this;
+ return RuntimeModule.nIsTransientInternal(JitHelpers.GetQCallModuleOnStack(ref thisAsLocal));
}
internal MetadataImport MetadataImport
{
unsafe
{
- return ModuleHandle.GetMetadataImport(GetNativeHandle());
+ return ModuleHandle.GetMetadataImport(this);
}
}
}
RuntimeType? retType = null;
object? keepAlive = null;
- GetType(GetNativeHandle(), className, throwOnError, ignoreCase, JitHelpers.GetObjectHandleOnStack(ref retType), JitHelpers.GetObjectHandleOnStack(ref keepAlive));
+ RuntimeModule thisAsLocal = this;
+ GetType(JitHelpers.GetQCallModuleOnStack(ref thisAsLocal), className, throwOnError, ignoreCase, JitHelpers.GetObjectHandleOnStack(ref retType), JitHelpers.GetObjectHandleOnStack(ref keepAlive));
GC.KeepAlive(keepAlive);
return retType;
}
internal string GetFullyQualifiedName()
{
string? fullyQualifiedName = null;
- GetFullyQualifiedName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref fullyQualifiedName));
+ RuntimeModule thisAsLocal = this;
+ GetFullyQualifiedName(JitHelpers.GetQCallModuleOnStack(ref thisAsLocal), JitHelpers.GetStringHandleOnStack(ref fullyQualifiedName));
return fullyQualifiedName!;
}
get
{
string? scopeName = null;
- GetScopeName(GetNativeHandle(), JitHelpers.GetStringHandleOnStack(ref scopeName));
+ RuntimeModule thisAsLocal = this;
+ GetScopeName(JitHelpers.GetQCallModuleOnStack(ref thisAsLocal),JitHelpers.GetStringHandleOnStack(ref scopeName));
return scopeName!;
}
}
{
return this;
}
+
+ internal IntPtr GetUnderlyingNativeHandle()
+ {
+ return m_pData;
+ }
#endregion
}
}
internal sealed override RuntimeTypeHandle GetTypeHandleInternal() => new RuntimeTypeHandle(this);
- public sealed override bool IsCollectible => RuntimeTypeHandle.IsCollectible(GetTypeHandleInternal());
+ public sealed override bool IsCollectible
+ {
+ get
+ {
+ RuntimeType thisType = this;
+ return RuntimeTypeHandle.IsCollectible(JitHelpers.GetQCallTypeHandleOnStack(ref thisType)) != Interop.BOOL.FALSE;
+ }
+ }
protected override TypeCode GetTypeCodeImpl()
{
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void _CompileMethod(IRuntimeMethodInfo method);
+ internal static extern void _CompileMethod(RuntimeMethodHandleInternal method);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern unsafe void _PrepareMethod(IRuntimeMethodInfo method, IntPtr* pInstantiation, int cInstantiation);
}
}
+ internal struct QCallModule
+ {
+ private IntPtr m_ptr;
+ private IntPtr m_module;
+ internal QCallModule(IntPtr pObject, System.Reflection.RuntimeModule module)
+ {
+ m_ptr = pObject;
+ m_module = module.GetUnderlyingNativeHandle();
+ }
+ internal QCallModule(IntPtr pObject, System.Reflection.Emit.ModuleBuilder module)
+ {
+ m_ptr = pObject;
+ m_module = module.GetNativeHandle().GetUnderlyingNativeHandle();
+ }
+ }
+
+ internal struct QCallAssembly
+ {
+ private IntPtr m_ptr;
+ private IntPtr m_assembly;
+ internal QCallAssembly(IntPtr pObject, System.Reflection.RuntimeAssembly assembly)
+ {
+ m_ptr = pObject;
+ m_assembly = assembly.GetUnderlyingNativeHandle();
+ }
+ }
+
+ internal struct QCallTypeHandle
+ {
+ private IntPtr m_ptr;
+ private IntPtr m_handle;
+ internal QCallTypeHandle(IntPtr pObject, RuntimeType type)
+ {
+ m_ptr = pObject;
+ if (type != null)
+ m_handle = type.m_handle;
+ else
+ m_handle = IntPtr.Zero;
+ }
+ }
+
// Helper class to assist with unsafe pinning of arbitrary objects.
// It's used by VM code.
internal class RawData
return new ObjectHandleOnStack((IntPtr)Unsafe.AsPointer(ref o));
}
+ // Wraps RuntimeModule into a handle. Used to pass RuntimeModule to native code wihtout letting it be collected
+ internal static QCallModule GetQCallModuleOnStack(ref System.Reflection.RuntimeModule module)
+ {
+ return new QCallModule((IntPtr)Unsafe.AsPointer(ref module), module);
+ }
+
+ internal static QCallModule GetQCallModuleOnStack(ref System.Reflection.Emit.ModuleBuilder module)
+ {
+ return new QCallModule((IntPtr)Unsafe.AsPointer(ref module), module);
+ }
+
+ // Wraps RuntimeAssembly into a handle. Used to pass RuntimeAssembly to native code wihtout letting it be collected
+ internal static QCallAssembly GetQCallAssemblyOnStack(ref System.Reflection.RuntimeAssembly assembly)
+ {
+ return new QCallAssembly((IntPtr)Unsafe.AsPointer(ref assembly), assembly);
+ }
+
+ // Wraps RuntimeTypeHandle into a handle. Used to pass RuntimeAssembly to native code wihtout letting it be collected
+ internal static QCallTypeHandle GetQCallTypeHandleOnStack(ref System.RuntimeTypeHandle rth)
+ {
+ return new QCallTypeHandle((IntPtr)Unsafe.AsPointer(ref rth.m_type), rth.m_type);
+ }
+
+ // Wraps RuntimeTypeHandle into a handle. Used to pass RuntimeAssembly to native code wihtout letting it be collected
+ internal static QCallTypeHandle GetQCallTypeHandleOnStack(ref System.RuntimeType type)
+ {
+ return new QCallTypeHandle((IntPtr)Unsafe.AsPointer(ref type), type);
+ }
+
// 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)
throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, nameof(m));
}
- InternalPrelink(rmi);
+ InternalPrelink(((IRuntimeMethodInfo)rmi).Value);
+ GC.KeepAlive(rmi);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void InternalPrelink(IRuntimeMethodInfo m);
+ private static extern void InternalPrelink(RuntimeMethodHandleInternal m);
[MethodImpl(MethodImplOptions.InternalCall)]
public static extern /* struct _EXCEPTION_POINTERS* */ IntPtr GetExceptionPointers();
if (m is RuntimeModule rtModule)
{
- return GetHINSTANCE(rtModule.GetNativeHandle());
+ return GetHINSTANCE(JitHelpers.GetQCallModuleOnStack(ref rtModule));
}
return (IntPtr)(-1);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern IntPtr GetHINSTANCE(RuntimeModule m);
+ private static extern IntPtr GetHINSTANCE(QCallModule m);
#endif // FEATURE_COMINTEROP
{
internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, bool throwOnError)
{
+ RuntimeAssembly rtAsm = (RuntimeAssembly)assembly;
return LoadByName(libraryName,
- ((RuntimeAssembly)assembly).GetNativeHandle(),
+ JitHelpers.GetQCallAssemblyOnStack(ref rtAsm),
searchPath.HasValue,
(uint) searchPath.GetValueOrDefault(),
throwOnError);
internal static extern IntPtr LoadFromPath(string libraryName, bool throwOnError);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern IntPtr LoadByName(string libraryName, RuntimeAssembly callingAssembly,
+ internal static extern IntPtr LoadByName(string libraryName, QCallAssembly callingAssembly,
bool hasDllImportSearchPathFlag, uint dllImportSearchPathFlag,
bool throwOnError);
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern IntPtr GetLoadContextForAssembly(RuntimeAssembly assembly);
+ private static extern IntPtr GetLoadContextForAssembly(QCallAssembly assembly);
// Returns the load context in which the specified assembly has been loaded
public static AssemblyLoadContext? GetLoadContext(Assembly assembly)
// We only support looking up load context for runtime assemblies.
if (rtAsm != null)
{
- IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(rtAsm);
+ RuntimeAssembly runtimeAssembly = rtAsm;
+ IntPtr ptrAssemblyLoadContext = GetLoadContextForAssembly(JitHelpers.GetQCallAssemblyOnStack(ref runtimeAssembly));
if (ptrAssemblyLoadContext == IntPtr.Zero)
{
// If the load context is returned null, then the assembly was bound using the TPA binder
// This is the RuntimeType for the type
- private RuntimeType m_type;
+ internal RuntimeType m_type;
public override int GetHashCode()
{
internal static extern Type[]? GetInterfaces(RuntimeType type);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetConstraints(RuntimeTypeHandle handle, ObjectHandleOnStack types);
+ private static extern void GetConstraints(QCallTypeHandle handle, ObjectHandleOnStack types);
internal Type[] GetConstraints()
{
Type[]? types = null;
- GetConstraints(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+
+ GetConstraints(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref types));
return types!;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern IntPtr GetGCHandle(RuntimeTypeHandle handle, GCHandleType type);
+ private static extern IntPtr GetGCHandle(QCallTypeHandle handle, GCHandleType type);
internal IntPtr GetGCHandle(GCHandleType type)
{
- return GetGCHandle(GetNativeHandle(), type);
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ return GetGCHandle(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), type);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern int GetNumVirtuals(RuntimeType type);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void VerifyInterfaceIsImplemented(RuntimeTypeHandle handle, RuntimeTypeHandle interfaceHandle);
+ private static extern void VerifyInterfaceIsImplemented(QCallTypeHandle handle, QCallTypeHandle interfaceHandle);
internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle)
{
- VerifyInterfaceIsImplemented(GetNativeHandle(), interfaceHandle.GetNativeHandle());
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle();
+ VerifyInterfaceIsImplemented(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetQCallTypeHandleOnStack(ref nativeInterfaceHandle));
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle handle, RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle);
+ private static extern RuntimeMethodHandleInternal GetInterfaceMethodImplementation(QCallTypeHandle handle, QCallTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle);
internal RuntimeMethodHandleInternal GetInterfaceMethodImplementation(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle)
{
- return GetInterfaceMethodImplementation(GetNativeHandle(), interfaceHandle.GetNativeHandle(), interfaceMethodHandle);
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ RuntimeTypeHandle nativeInterfaceHandle = interfaceHandle.GetNativeHandle();
+ return GetInterfaceMethodImplementation(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetQCallTypeHandleOnStack(ref nativeInterfaceHandle), interfaceMethodHandle);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
[return: MarshalAs(UnmanagedType.Bool)]
- private static extern bool _IsVisible(RuntimeTypeHandle typeHandle);
+ private static extern bool _IsVisible(QCallTypeHandle typeHandle);
internal static bool IsVisible(RuntimeType type)
{
- return _IsVisible(new RuntimeTypeHandle(type));
+ return _IsVisible(JitHelpers.GetQCallTypeHandleOnStack(ref type));
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool IsValueType(RuntimeType type);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void ConstructName(RuntimeTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString);
+ private static extern void ConstructName(QCallTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString);
internal string ConstructName(TypeNameFormatFlags formatFlags)
{
string? name = null;
- ConstructName(GetNativeHandle(), formatFlags, JitHelpers.GetStringHandleOnStack(ref name));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ ConstructName(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), formatFlags, JitHelpers.GetStringHandleOnStack(ref name));
return name!;
}
internal static extern IRuntimeMethodInfo GetDeclaringMethod(RuntimeType type);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetDefaultConstructor(RuntimeTypeHandle handle, ObjectHandleOnStack method);
+ private static extern void GetDefaultConstructor(QCallTypeHandle handle, ObjectHandleOnStack method);
internal IRuntimeMethodInfo? GetDefaultConstructor()
{
IRuntimeMethodInfo? ctor = null;
- GetDefaultConstructor(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref ctor));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ GetDefaultConstructor(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref ctor));
return ctor;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);
+ private static extern void GetTypeByNameUsingCARules(string name, QCallModule scope, ObjectHandleOnStack type);
internal static RuntimeType GetTypeByNameUsingCARules(string name, RuntimeModule scope)
{
throw new ArgumentException(null, nameof(name));
RuntimeType type = null!;
- GetTypeByNameUsingCARules(name, scope.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
+ GetTypeByNameUsingCARules(name, JitHelpers.GetQCallModuleOnStack(ref scope), JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void GetInstantiation(RuntimeTypeHandle type, ObjectHandleOnStack types, bool fAsRuntimeTypeArray);
+ internal static extern void GetInstantiation(QCallTypeHandle type, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray);
internal RuntimeType[] GetInstantiationInternal()
{
RuntimeType[] types = null!;
- GetInstantiation(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types), true);
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ GetInstantiation(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref types), Interop.BOOL.TRUE);
return types;
}
internal Type[] GetInstantiationPublic()
{
Type[] types = null!;
- GetInstantiation(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types), false);
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ GetInstantiation(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref types), Interop.BOOL.FALSE);
return types;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void Instantiate(RuntimeTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type);
+ private static extern void Instantiate(QCallTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type);
internal RuntimeType Instantiate(Type[]? inst)
{
fixed (IntPtr* pInst = instHandles)
{
RuntimeType type = null!;
- Instantiate(GetNativeHandle(), pInst, instCount, JitHelpers.GetObjectHandleOnStack(ref type));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ Instantiate(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), pInst, instCount, JitHelpers.GetObjectHandleOnStack(ref type));
GC.KeepAlive(inst);
return type;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void MakeArray(RuntimeTypeHandle handle, int rank, ObjectHandleOnStack type);
+ private static extern void MakeArray(QCallTypeHandle handle, int rank, ObjectHandleOnStack type);
internal RuntimeType MakeArray(int rank)
{
RuntimeType type = null!;
- MakeArray(GetNativeHandle(), rank, JitHelpers.GetObjectHandleOnStack(ref type));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ MakeArray(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), rank, JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void MakeSZArray(RuntimeTypeHandle handle, ObjectHandleOnStack type);
+ private static extern void MakeSZArray(QCallTypeHandle handle, ObjectHandleOnStack type);
internal RuntimeType MakeSZArray()
{
RuntimeType type = null!;
- MakeSZArray(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ MakeSZArray(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void MakeByRef(RuntimeTypeHandle handle, ObjectHandleOnStack type);
+ private static extern void MakeByRef(QCallTypeHandle handle, ObjectHandleOnStack type);
internal RuntimeType MakeByRef()
{
RuntimeType type = null!;
- MakeByRef(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ MakeByRef(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void MakePointer(RuntimeTypeHandle handle, ObjectHandleOnStack type);
+ private static extern void MakePointer(QCallTypeHandle handle, ObjectHandleOnStack type);
internal RuntimeType MakePointer()
{
RuntimeType type = null!;
- MakePointer(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
+ RuntimeTypeHandle nativeHandle = GetNativeHandle();
+ MakePointer(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern bool IsCollectible(RuntimeTypeHandle handle);
+ internal static extern Interop.BOOL IsCollectible(QCallTypeHandle handle);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern bool HasInstantiation(RuntimeType type);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetGenericTypeDefinition(RuntimeTypeHandle type, ObjectHandleOnStack retType);
+ private static extern void GetGenericTypeDefinition(QCallTypeHandle type, ObjectHandleOnStack retType);
internal static RuntimeType GetGenericTypeDefinition(RuntimeType type)
{
RuntimeType retType = type;
if (HasInstantiation(retType) && !IsGenericTypeDefinition(retType))
- GetGenericTypeDefinition(retType.GetTypeHandleInternal(), JitHelpers.GetObjectHandleOnStack(ref retType));
+ {
+ RuntimeTypeHandle nativeHandle = retType.GetTypeHandleInternal();
+ GetGenericTypeDefinition(JitHelpers.GetQCallTypeHandleOnStack(ref nativeHandle), JitHelpers.GetObjectHandleOnStack(ref retType));
+ }
return retType;
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- [return: MarshalAs(UnmanagedType.Bool)]
- internal static extern bool GetIsCollectible(RuntimeMethodHandleInternal handle);
+ internal static extern Interop.BOOL GetIsCollectible(RuntimeMethodHandleInternal handle);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern bool IsCAVisibleFromDecoratedType(
- RuntimeTypeHandle attrTypeHandle,
- IRuntimeMethodInfo attrCtor,
- RuntimeTypeHandle sourceTypeHandle,
- RuntimeModule sourceModule);
+ internal static extern Interop.BOOL IsCAVisibleFromDecoratedType(
+ QCallTypeHandle attrTypeHandle,
+ RuntimeMethodHandleInternal attrCtor,
+ QCallTypeHandle sourceTypeHandle,
+ QCallModule sourceModule);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern IRuntimeMethodInfo? _GetCurrentMethod(ref StackCrawlMark stackMark);
internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format, StringHandleOnStack retString);
+ private static extern void ConstructInstantiation(RuntimeMethodHandleInternal method, TypeNameFormatFlags format, StringHandleOnStack retString);
internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format)
{
string? name = null;
- ConstructInstantiation(EnsureNonNullMethodInfo(method), format, JitHelpers.GetStringHandleOnStack(ref name));
+ IRuntimeMethodInfo methodInfo = EnsureNonNullMethodInfo(method);
+ ConstructInstantiation(methodInfo.Value, format, JitHelpers.GetStringHandleOnStack(ref name));
+ GC.KeepAlive(methodInfo);
return name!;
}
internal static extern object InvokeMethod(object? target, object[]? arguments, Signature sig, bool constructor, bool wrapExceptions);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, bool fAsRuntimeTypeArray);
+ private static extern void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, Interop.BOOL fAsRuntimeTypeArray);
internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method)
{
RuntimeType[] types = null!;
- GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), true);
+ GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), Interop.BOOL.TRUE);
GC.KeepAlive(method);
return types;
}
internal static RuntimeType[] GetMethodInstantiationInternal(RuntimeMethodHandleInternal method)
{
RuntimeType[] types = null!;
- GetMethodInstantiation(method, JitHelpers.GetObjectHandleOnStack(ref types), true);
+ GetMethodInstantiation(method, JitHelpers.GetObjectHandleOnStack(ref types), Interop.BOOL.TRUE);
return types;
}
internal static Type[] GetMethodInstantiationPublic(IRuntimeMethodInfo method)
{
RuntimeType[] types = null!;
- GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), false);
+ GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), Interop.BOOL.FALSE);
GC.KeepAlive(method);
return types;
}
internal static extern bool IsTypicalMethodDefinition(IRuntimeMethodInfo method);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetTypicalMethodDefinition(IRuntimeMethodInfo method, ObjectHandleOnStack outMethod);
+ private static extern void GetTypicalMethodDefinition(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod);
internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method)
{
if (!IsTypicalMethodDefinition(method))
- GetTypicalMethodDefinition(method, JitHelpers.GetObjectHandleOnStack(ref method));
+ {
+ GetTypicalMethodDefinition(method.Value, JitHelpers.GetObjectHandleOnStack(ref method));
+ GC.KeepAlive(method);
+ }
return method;
}
internal static int GetGenericParameterCount(IRuntimeMethodInfo method) => GetGenericParameterCount(method.Value);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void StripMethodInstantiation(IRuntimeMethodInfo method, ObjectHandleOnStack outMethod);
+ private static extern void StripMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack outMethod);
internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method)
{
IRuntimeMethodInfo strippedMethod = method;
- StripMethodInstantiation(method, JitHelpers.GetObjectHandleOnStack(ref strippedMethod));
+ StripMethodInstantiation(method.Value, JitHelpers.GetObjectHandleOnStack(ref strippedMethod));
+ GC.KeepAlive(method);
return strippedMethod;
}
fixed (IntPtr* typeInstArgs = typeInstantiationContextHandles, methodInstArgs = methodInstantiationContextHandles)
{
RuntimeType type = null!;
- ResolveType(module, typeToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref type));
+ ResolveType(JitHelpers.GetQCallModuleOnStack(ref module), typeToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref type));
GC.KeepAlive(typeInstantiationContext);
GC.KeepAlive(methodInstantiationContext);
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void ResolveType(RuntimeModule module,
+ private static extern void ResolveType(QCallModule module,
int typeToken,
IntPtr* typeInstArgs,
int typeInstCount,
fixed (IntPtr* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext)
{
- return ResolveMethod(module.GetNativeHandle(), methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
+ return ResolveMethod(JitHelpers.GetQCallModuleOnStack(ref module), methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
}
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern RuntimeMethodHandleInternal ResolveMethod(RuntimeModule module,
+ private static extern RuntimeMethodHandleInternal ResolveMethod(QCallModule module,
int methodToken,
IntPtr* typeInstArgs,
int typeInstCount,
fixed (IntPtr* typeInstArgs = typeInstantiationContextHandles, methodInstArgs = methodInstantiationContextHandles)
{
IRuntimeFieldInfo field = null!;
- ResolveField(module.GetNativeHandle(), fieldToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref field));
+ ResolveField(JitHelpers.GetQCallModuleOnStack(ref module), fieldToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref field));
GC.KeepAlive(typeInstantiationContext);
GC.KeepAlive(methodInstantiationContext);
return field;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void ResolveField(RuntimeModule module,
+ private static extern void ResolveField(QCallModule module,
int fieldToken,
IntPtr* typeInstArgs,
int typeInstCount,
ObjectHandleOnStack retField);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern bool _ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash);
+ private static extern Interop.BOOL _ContainsPropertyMatchingHash(QCallModule module, int propertyToken, uint hash);
internal static bool ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash)
{
- return _ContainsPropertyMatchingHash(module.GetNativeHandle(), propertyToken, hash);
+ return _ContainsPropertyMatchingHash(JitHelpers.GetQCallModuleOnStack(ref module), propertyToken, hash) != Interop.BOOL.FALSE;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern void GetModuleType(RuntimeModule handle, ObjectHandleOnStack type);
+ internal static extern void GetModuleType(QCallModule handle, ObjectHandleOnStack type);
internal static RuntimeType GetModuleType(RuntimeModule module)
{
RuntimeType type = null!;
- GetModuleType(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
+ GetModuleType(JitHelpers.GetQCallModuleOnStack(ref module), JitHelpers.GetObjectHandleOnStack(ref type));
return type;
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void GetPEKind(RuntimeModule handle, out int peKind, out int machine);
+ private unsafe static extern void GetPEKind(QCallModule handle, int *peKind, int *machine);
// making this internal, used by Module.GetPEKind
- internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
+ internal unsafe static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
int lKind, lMachine;
- GetPEKind(module.GetNativeHandle(), out lKind, out lMachine);
+ GetPEKind(JitHelpers.GetQCallModuleOnStack(ref module), &lKind, &lMachine);
peKind = (PortableExecutableKinds)lKind;
machine = (ImageFileMachine)lMachine;
}
public static void SpinWait(int iterations) => SpinWaitInternal(iterations);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern bool YieldInternal();
+ private static extern Interop.BOOL YieldInternal();
- public static bool Yield() => YieldInternal();
+ public static bool Yield() => YieldInternal() != Interop.BOOL.FALSE;
[MethodImpl(MethodImplOptions.NoInlining)]
private static Thread InitializeCurrentThread() => (t_currentThread = GetCurrentThreadNative());
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- internal static extern bool RequestWorkerThread();
+ internal static extern Interop.BOOL RequestWorkerThread();
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern unsafe bool PostQueuedCompletionStatus(NativeOverlapped* overlapped);
{
gcInfo = new Amd64.GcInfo(Image, unwindOffset + unwindInfo.Size, Machine, R2RHeader.MajorVersion);
}
+ catch (OverflowException)
+ {
+ Console.WriteLine($"Warning: Could not parse GC Info for method: {method.SignatureString}");
+ }
catch (IndexOutOfRangeException)
{
Console.WriteLine($"Warning: Could not parse GC Info for method: {method.SignatureString}");
}
-
+
}
}
else if (Machine == Machine.I386)
// Return a MemberRef token given a RuntimeFieldInfo
//
//******************************************************************************
-mdMemberRef QCALLTYPE COMModule::GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, void * th, mdFieldDef tkField)
+mdMemberRef QCALLTYPE COMModule::GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField)
{
QCALL_CONTRACT;
}
else
{
- TypeHandle typeHandle = TypeHandle::FromPtr(th);
+ TypeHandle typeHandle = th.AsTypeHandle();
RefClassWriter * pRCW = pModule->GetReflectionModule()->GetClassWriter();
_ASSERTE(pRCW);
// GetMemberRefOfFieldInfo
// This function will return a memberRef token given a FieldInfo
static
- mdMemberRef QCALLTYPE GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, EnregisteredTypeHandle th, mdFieldDef tkField);
+ mdMemberRef QCALLTYPE GetMemberRefOfFieldInfo(QCall::ModuleHandle pModule, mdTypeDef tr, QCall::TypeHandle th, mdFieldDef tkField);
// GetMemberRefFromSignature
// This function will return the MemberRef token given the signature from managed code
virtual BinderClassID GetManagedTypeBinderID() = 0;
};
-class ILIRuntimeMethodInfoMarshaler : public ILReflectionObjectMarshaler
-{
-protected:
- virtual BinderFieldID GetObjectFieldID() { LIMITED_METHOD_CONTRACT; return FIELD__STUBMETHODINFO__HANDLE; }
- virtual BinderClassID GetManagedTypeBinderID() { LIMITED_METHOD_CONTRACT; return CLASS__STUBMETHODINFO; }
-};
-
-class ILRuntimeModuleMarshaler : public ILReflectionObjectMarshaler
-{
-protected:
- virtual BinderFieldID GetObjectFieldID() { LIMITED_METHOD_CONTRACT; return FIELD__MODULE__DATA; }
- virtual BinderClassID GetManagedTypeBinderID() { LIMITED_METHOD_CONTRACT; return CLASS__MODULE; }
-};
-
-class ILRuntimeAssemblyMarshaler : public ILReflectionObjectMarshaler
-{
-protected:
- virtual BinderFieldID GetObjectFieldID() { LIMITED_METHOD_CONTRACT; return FIELD__ASSEMBLY__HANDLE; }
- virtual BinderClassID GetManagedTypeBinderID() { LIMITED_METHOD_CONTRACT; return CLASS__ASSEMBLY; }
-};
-
class ILRuntimeTypeHandleMarshaler : public ILReflectionObjectMarshaler
{
protected:
m_args.m_pMT = m_pMT;
m_type = MARSHAL_TYPE_CRITICALHANDLE;
}
- else if (sig.IsClassThrowing(pModule, g_ReflectionMethodInterfaceName, pTypeContext))
- {
- if (nativeType != NATIVE_TYPE_DEFAULT)
- {
- IfFailGoto(E_FAIL, lFail);
- }
-
- m_type = MARSHAL_TYPE_RUNTIMEMETHODINFO;
- }
#ifdef FEATURE_COMINTEROP
else if (m_pMT->IsInterface())
{
}
m_type = MARSHAL_TYPE_LAYOUTCLASSPTR;
m_args.m_pMT = m_pMT;
- }
- else if (sig.IsClassThrowing(pModule, g_ReflectionModuleName, pTypeContext))
- {
- if (nativeType != NATIVE_TYPE_DEFAULT)
- {
- IfFailGoto(E_FAIL, lFail);
- }
-
- m_type = MARSHAL_TYPE_RUNTIMEMODULE;
- }
- else if (sig.IsClassThrowing(pModule, g_ReflectionAssemblyName, pTypeContext))
- {
- if (nativeType != NATIVE_TYPE_DEFAULT)
- {
- IfFailGoto(E_FAIL, lFail);
- }
-
- m_type = MARSHAL_TYPE_RUNTIMEASSEMBLY;
}
#ifdef FEATURE_COMINTEROP
else if (m_ms == MARSHAL_SCENARIO_WINRT && sig.IsClassThrowing(pModule, g_SystemUriClassName, pTypeContext))
case MARSHAL_TYPE_RUNTIMEMETHODHANDLE:
strRetVal = W("RuntimeMethodHandle");
break;
- case MARSHAL_TYPE_RUNTIMEMETHODINFO:
- strRetVal = W("RuntimeMethodInfo");
- break;
- case MARSHAL_TYPE_RUNTIMEMODULE:
- strRetVal = W("RuntimeModule");
- break;
- case MARSHAL_TYPE_RUNTIMEASSEMBLY:
- strRetVal = W("RuntimeAssembly");
- break;
default:
strRetVal = W("<UNKNOWN>");
break;
DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMETYPEHANDLE, RuntimeTypeHandleMarshaler, false)
DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMEMETHODHANDLE, RuntimeMethodHandleMarshaler, false)
DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMEFIELDHANDLE, RuntimeFieldHandleMarshaler, false)
-DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMEMETHODINFO, IRuntimeMethodInfoMarshaler, false)
-DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMEMODULE, RuntimeModuleMarshaler, false)
-DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_RUNTIMEASSEMBLY, RuntimeAssemblyMarshaler, false)
#ifdef FEATURE_COMINTEROP
DEFINE_MARSHALER_TYPE(MARSHAL_TYPE_NULLABLE, NullableMarshaler, true)
GCX_COOP();
- TypeHandle typeHandle = MscorlibBinder::GetClass(CLASS__GUID);
+ ::TypeHandle typeHandle = MscorlibBinder::GetClass(CLASS__GUID);
BASEARRAYREF arr = (BASEARRAYREF) AllocateSzArray(typeHandle.MakeSZArray(), length);
memcpyNoGCRefs(arr->GetDataPtr(), p, length * sizeof(GUID));
Set(arr);
struct AssemblyHandle
{
+ Object ** m_ppObject;
DomainAssembly * m_pAssembly;
operator DomainAssembly * ()
struct ModuleHandle
{
+ Object ** m_ppObject;
Module * m_pModule;
operator Module * ()
}
};
+ struct TypeHandle
+ {
+ Object ** m_ppObject;
+ PTR_VOID m_pTypeHandle;
+
+ ::TypeHandle AsTypeHandle()
+ {
+ LIMITED_METHOD_CONTRACT;
+ return ::TypeHandle::FromPtr(m_pTypeHandle);
+ }
+ };
+
struct LoaderAllocatorHandle
{
LoaderAllocator * m_pLoaderAllocator;
}
};
-void QCALLTYPE ReflectionEnum::GetEnumValuesAndNames(EnregisteredTypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames)
+void QCALLTYPE ReflectionEnum::GetEnumValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle th = TypeHandle::FromPtr(pEnumType);
+ TypeHandle th = pEnumType.AsTypeHandle();
if (!th.IsEnum())
COMPlusThrow(kArgumentException, W("Arg_MustBeEnum"));
static FCDECL1(INT32, InternalGetCorElementType, Object *pRefThis);
static
- void QCALLTYPE GetEnumValuesAndNames(EnregisteredTypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames);
+ void QCALLTYPE GetEnumValuesAndNames(QCall::TypeHandle pEnumType, QCall::ObjectHandleOnStack pReturnValues, QCall::ObjectHandleOnStack pReturnNames, BOOL fGetNames);
static FCDECL2_IV(Object*, InternalBoxEnum, ReflectClassBaseObject* pEnumType, INT64 value);
static FCDECL2(FC_BOOL_RET, InternalEquals, Object *pRefThis, Object* pRefTarget);
}
BOOL QCALLTYPE RuntimeMethodHandle::IsCAVisibleFromDecoratedType(
- EnregisteredTypeHandle targetTypeHandle,
+ QCall::TypeHandle targetTypeHandle,
MethodDesc * pTargetCtor,
- EnregisteredTypeHandle sourceTypeHandle,
+ QCall::TypeHandle sourceTypeHandle,
QCall::ModuleHandle sourceModuleHandle)
{
QCALL_CONTRACT;
BOOL bResult = TRUE;
BEGIN_QCALL;
- TypeHandle sourceHandle = TypeHandle::FromPtr(sourceTypeHandle);
- TypeHandle targetHandle = TypeHandle::FromPtr(targetTypeHandle);
+ TypeHandle sourceHandle = sourceTypeHandle.AsTypeHandle();
+ TypeHandle targetHandle = targetTypeHandle.AsTypeHandle();
_ASSERTE((sourceHandle.IsNull() || !sourceHandle.IsTypeDesc()) &&
!targetHandle.IsNull() &&
END_QCALL;
}
-void QCALLTYPE RuntimeTypeHandle::ConstructName(EnregisteredTypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString)
+void QCALLTYPE RuntimeTypeHandle::ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString)
{
QCALL_CONTRACT;
BEGIN_QCALL;
StackSString ss;
- TypeString::AppendType(ss, TypeHandle::FromPtr(pTypeHandle), format);
+ TypeString::AppendType(ss, pTypeHandle.AsTypeHandle(), format);
retString.Set(ss);
END_QCALL;
return refReturn;
}
-void QCALLTYPE RuntimeTypeHandle::GetConstraints(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray)
+void QCALLTYPE RuntimeTypeHandle::GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypeArray)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle);
+ TypeHandle typeHandle = pTypeHandle.AsTypeHandle();
if (!typeHandle.IsGenericVariable())
COMPlusThrow(kArgumentException, W("Arg_InvalidHandle"));
BOOL
QCALLTYPE
RuntimeTypeHandle::IsVisible(
- EnregisteredTypeHandle pTypeHandle)
+ QCall::TypeHandle pTypeHandle)
{
CONTRACTL
{
BEGIN_QCALL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle);
+ TypeHandle typeHandle = pTypeHandle.AsTypeHandle();
_ASSERTE(!typeHandle.IsNull());
}
FCIMPLEND
-PVOID QCALLTYPE RuntimeTypeHandle::GetGCHandle(EnregisteredTypeHandle pTypeHandle, INT32 handleType)
+PVOID QCALLTYPE RuntimeTypeHandle::GetGCHandle(QCall::TypeHandle pTypeHandle, INT32 handleType)
{
QCALL_CONTRACT;
GCX_COOP();
- TypeHandle th = TypeHandle::FromPtr(pTypeHandle);
+ TypeHandle th = pTypeHandle.AsTypeHandle();
assert(handleType >= HNDTYPE_WEAK_SHORT && handleType <= HNDTYPE_WEAK_WINRT);
objHandle = AppDomain::GetCurrentDomain()->CreateTypedHandle(NULL, static_cast<HandleType>(handleType));
th.GetLoaderAllocator()->RegisterHandleForCleanup(objHandle);
return objHandle;
}
-void QCALLTYPE RuntimeTypeHandle::VerifyInterfaceIsImplemented(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pIFaceHandle)
+void QCALLTYPE RuntimeTypeHandle::VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle);
- TypeHandle ifaceHandle = TypeHandle::FromPtr(pIFaceHandle);
+ TypeHandle typeHandle = pTypeHandle.AsTypeHandle();
+ TypeHandle ifaceHandle = pIFaceHandle.AsTypeHandle();
if (typeHandle.IsGenericVariable())
COMPlusThrow(kArgumentException, W("Arg_InvalidHandle"));
END_QCALL;
}
-MethodDesc* QCALLTYPE RuntimeTypeHandle::GetInterfaceMethodImplementation(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pOwner, MethodDesc * pMD)
+MethodDesc* QCALLTYPE RuntimeTypeHandle::GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle);
- TypeHandle thOwnerOfMD = TypeHandle::FromPtr(pOwner);
+ TypeHandle typeHandle = pTypeHandle.AsTypeHandle();
+ TypeHandle thOwnerOfMD = pOwner.AsTypeHandle();
// Ok to have INVALID_SLOT in the case where abstract class does not implement an interface method.
// This case can not be reproed using C# "implements" all interface methods
return pResult;
}
-void QCALLTYPE RuntimeTypeHandle::GetDefaultConstructor(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod)
+void QCALLTYPE RuntimeTypeHandle::GetDefaultConstructor(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod)
{
QCALL_CONTRACT;
MethodDesc* pCtor = NULL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pTypeHandle);
+ TypeHandle typeHandle = pTypeHandle.AsTypeHandle();
if (!typeHandle.IsTypeDesc())
{
}
FCIMPLEND
-void QCALLTYPE RuntimeTypeHandle::GetInstantiation(EnregisteredTypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray)
+void QCALLTYPE RuntimeTypeHandle::GetInstantiation(QCall::TypeHandle pType, QCall::ObjectHandleOnStack retTypes, BOOL fAsRuntimeTypeArray)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle typeHandle = TypeHandle::FromPtr(pType);
+ TypeHandle typeHandle = pType.AsTypeHandle();
Instantiation inst = typeHandle.GetInstantiation();
GCX_COOP();
retTypes.Set(CopyRuntimeTypeHandles(NULL, inst.GetRawArgs(), inst.GetNumArgs(), fAsRuntimeTypeArray ? CLASS__CLASS : CLASS__TYPE));
return;
}
-void QCALLTYPE RuntimeTypeHandle::MakeArray(EnregisteredTypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
TypeHandle arrayHandle;
BEGIN_QCALL;
- arrayHandle = TypeHandle::FromPtr(pTypeHandle).MakeArray(rank);
+ arrayHandle = pTypeHandle.AsTypeHandle().MakeArray(rank);
GCX_COOP();
retType.Set(arrayHandle.GetManagedClassObject());
END_QCALL;
return;
}
-void QCALLTYPE RuntimeTypeHandle::MakeSZArray(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
TypeHandle arrayHandle;
BEGIN_QCALL;
- arrayHandle = TypeHandle::FromPtr(pTypeHandle).MakeSZArray();
+ arrayHandle = pTypeHandle.AsTypeHandle().MakeSZArray();
GCX_COOP();
retType.Set(arrayHandle.GetManagedClassObject());
END_QCALL;
return;
}
-void QCALLTYPE RuntimeTypeHandle::MakePointer(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
TypeHandle pointerHandle;
BEGIN_QCALL;
- pointerHandle = TypeHandle::FromPtr(pTypeHandle).MakePointer();
+ pointerHandle = pTypeHandle.AsTypeHandle().MakePointer();
GCX_COOP();
retType.Set(pointerHandle.GetManagedClassObject());
END_QCALL;
return;
}
-void QCALLTYPE RuntimeTypeHandle::MakeByRef(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
TypeHandle byRefHandle;
BEGIN_QCALL;
- byRefHandle = TypeHandle::FromPtr(pTypeHandle).MakeByRef();
+ byRefHandle = pTypeHandle.AsTypeHandle().MakeByRef();
GCX_COOP();
retType.Set(byRefHandle.GetManagedClassObject());
END_QCALL;
return;
}
-BOOL QCALLTYPE RuntimeTypeHandle::IsCollectible(EnregisteredTypeHandle pTypeHandle)
+BOOL QCALLTYPE RuntimeTypeHandle::IsCollectible(QCall::TypeHandle pTypeHandle)
{
QCALL_CONTRACT;
BOOL retVal = FALSE;
BEGIN_QCALL;
- retVal = TypeHandle::FromPtr(pTypeHandle).GetLoaderAllocator()->IsCollectible();
+ retVal = pTypeHandle.AsTypeHandle().GetLoaderAllocator()->IsCollectible();
END_QCALL;
return retVal;
}
-void QCALLTYPE RuntimeTypeHandle::Instantiate(EnregisteredTypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
TypeHandle type;
BEGIN_QCALL;
- type = TypeHandle::FromPtr(pTypeHandle).Instantiate(Instantiation(pInstArray, cInstArray));
+ type = pTypeHandle.AsTypeHandle().Instantiate(Instantiation(pInstArray, cInstArray));
GCX_COOP();
retType.Set(type.GetManagedClassObject());
END_QCALL;
return;
}
-void QCALLTYPE RuntimeTypeHandle::GetGenericTypeDefinition(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
+void QCALLTYPE RuntimeTypeHandle::GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType)
{
QCALL_CONTRACT;
BEGIN_QCALL;
- TypeHandle genericType = TypeHandle::FromPtr(pTypeHandle);
+ TypeHandle genericType = pTypeHandle.AsTypeHandle();
typeDef = ClassLoader::LoadTypeDefThrowing(genericType.GetModule(),
genericType.GetMethodTable()->GetCl(),
static FCDECL2(Object*, CreateCaInstance, ReflectClassBaseObject* refCaType, ReflectMethodObject* pCtorUNSAFE);
static
- void QCALLTYPE MakeByRef(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE MakeByRef(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
static
- void QCALLTYPE MakePointer(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE MakePointer(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
static
- void QCALLTYPE MakeSZArray(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE MakeSZArray(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
static
- void QCALLTYPE MakeArray(EnregisteredTypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE MakeArray(QCall::TypeHandle pTypeHandle, INT32 rank, QCall::ObjectHandleOnStack retType);
- static BOOL QCALLTYPE IsCollectible(EnregisteredTypeHandle pTypeHandle);
+ static BOOL QCALLTYPE IsCollectible(QCall::TypeHandle pTypeHandle);
static FCDECL1(ReflectClassBaseObject*, GetRuntimeType, void *th);
#endif //FEATURE_COMINTEROP
static
- void QCALLTYPE PrepareMemberInfoCache(EnregisteredTypeHandle pMemberInfoCache);
+ void QCALLTYPE PrepareMemberInfoCache(QCall::TypeHandle pMemberInfoCache);
static
- void QCALLTYPE ConstructName(EnregisteredTypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString);
+ void QCALLTYPE ConstructName(QCall::TypeHandle pTypeHandle, DWORD format, QCall::StringHandleOnStack retString);
static
void QCALLTYPE GetTypeByNameUsingCARules(LPCWSTR pwzClassName, QCall::ModuleHandle pModule, QCall::ObjectHandleOnStack retType);
static FCDECL1(ReflectMethodObject*, GetDeclaringMethod, ReflectClassBaseObject *pType);
static
- void QCALLTYPE GetDefaultConstructor(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod);
+ void QCALLTYPE GetDefaultConstructor(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retMethod);
static FCDECL1(ReflectClassBaseObject*, GetDeclaringType, ReflectClassBaseObject* pType);
static FCDECL1(FC_BOOL_RET, IsValueType, ReflectClassBaseObject* pType);
static FCDECL1(FC_BOOL_RET, IsByRefLike, ReflectClassBaseObject* pType);
static
- BOOL QCALLTYPE IsVisible(EnregisteredTypeHandle pTypeHandle);
+ BOOL QCALLTYPE IsVisible(QCall::TypeHandle pTypeHandle);
static FCDECL2(FC_BOOL_RET, IsComObject, ReflectClassBaseObject *pType, CLR_BOOL isGenericCOM);
static FCDECL2(FC_BOOL_RET, CanCastTo, ReflectClassBaseObject *pType, ReflectClassBaseObject *pTarget);
FCDECL1(FC_BOOL_RET, ContainsGenericVariables, PTR_ReflectClassBaseObject pType);
static
- void QCALLTYPE GetInstantiation(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray);
+ void QCALLTYPE GetInstantiation(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType, BOOL fAsRuntimeTypeArray);
static
- void QCALLTYPE Instantiate(EnregisteredTypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE Instantiate(QCall::TypeHandle pTypeHandle, TypeHandle * pInstArray, INT32 cInstArray, QCall::ObjectHandleOnStack retType);
static
- void QCALLTYPE GetGenericTypeDefinition(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
+ void QCALLTYPE GetGenericTypeDefinition(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retType);
static FCDECL2(FC_BOOL_RET, CompareCanonicalHandles, PTR_ReflectClassBaseObject pLeft, PTR_ReflectClassBaseObject pRight);
static FCDECL1(PtrArray*, GetInterfaces, ReflectClassBaseObject *pType);
static
- void QCALLTYPE GetConstraints(EnregisteredTypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes);
+ void QCALLTYPE GetConstraints(QCall::TypeHandle pTypeHandle, QCall::ObjectHandleOnStack retTypes);
static
- PVOID QCALLTYPE GetGCHandle(EnregisteredTypeHandle pTypeHandle, INT32 handleType);
+ PVOID QCALLTYPE GetGCHandle(QCall::TypeHandle pTypeHandle, INT32 handleType);
static FCDECL1(INT32, GetCorElementType, PTR_ReflectClassBaseObject pType);
static FCDECL1(ReflectClassBaseObject*, GetElementType, ReflectClassBaseObject* pType);
static FCDECL1(INT32, GetNumVirtuals, ReflectClassBaseObject *pType);
static
- void QCALLTYPE VerifyInterfaceIsImplemented(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pIFaceHandle);
+ void QCALLTYPE VerifyInterfaceIsImplemented(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pIFaceHandle);
static
- MethodDesc* QCALLTYPE GetInterfaceMethodImplementation(EnregisteredTypeHandle pTypeHandle, EnregisteredTypeHandle pOwner, MethodDesc * pMD);
+ MethodDesc* QCALLTYPE GetInterfaceMethodImplementation(QCall::TypeHandle pTypeHandle, QCall::TypeHandle pOwner, MethodDesc * pMD);
static FCDECL3(FC_BOOL_RET, GetFields, ReflectClassBaseObject *pType, INT32 **result, INT32 *pCount);
static
BOOL QCALLTYPE IsCAVisibleFromDecoratedType(
- EnregisteredTypeHandle targetTypeHandle,
+ QCall::TypeHandle targetTypeHandle,
MethodDesc * pTargetCtor,
- EnregisteredTypeHandle sourceTypeHandle,
+ QCall::TypeHandle sourceTypeHandle,
QCall::ModuleHandle sourceModuleHandle);
static FCDECL4(void, SerializationInvoke, ReflectMethodObject *pMethodUNSAFE, Object* targetUNSAFE,
projects / platform / upstream / coreclr.git / commitdiff