File: system\runtimehandles.cs
Project: ndp\clr\src\bcl\mscorlib.csproj (mscorlib)
// ==++==
// 
//   Copyright(c) Microsoft Corporation.  All rights reserved.
// 
// ==--==
 
namespace System 
{
    using System;
    using System.Reflection;
    using System.Reflection.Emit;
    using System.Runtime;
    using System.Runtime.ConstrainedExecution;
    using System.Diagnostics;
    using System.Runtime.Serialization;
    using System.Runtime.CompilerServices;
    using System.Runtime.InteropServices;
    using System.Threading;
    using System.Runtime.Versioning;
    using System.Text;
    using System.Globalization;
    using System.Security;
    using System.Security.Permissions;
    using Microsoft.Win32.SafeHandles;
    using System.Diagnostics.Contracts;
    using StackCrawlMark = System.Threading.StackCrawlMark;
    
    [Serializable()]
    [System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct RuntimeTypeHandle : ISerializable
    {
        // Returns handle for interop with EE. The handle is guaranteed to be non-null.
        internal RuntimeTypeHandle GetNativeHandle()
        {
            // Create local copy to avoid ----s
            RuntimeType type = m_type;
            if (type == null)
                throw new ArgumentNullException(null, Environment.GetResourceString("Arg_InvalidHandle"));
            return new RuntimeTypeHandle(type);
        }
 
        // Returns type for interop with EE. The type is guaranteed to be non-null.
        internal RuntimeType GetTypeChecked()
        {
            // Create local copy to avoid ----s
            RuntimeType type = m_type;
            if (type == null)
                throw new ArgumentNullException(null, Environment.GetResourceString("Arg_InvalidHandle"));
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsInstanceOfType(RuntimeType type, Object o);
        
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal unsafe static Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers)
        {
            Type type = typeStart;
 
            if (genericArgs != null)
            {
                type = type.MakeGenericType(genericArgs);
            }
 
            if (cModifiers > 0)
            {
                int* arModifiers = (int*)pModifiers.ToPointer();
                for(int i = 0; i < cModifiers; i++)
                {
                    if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.Ptr)
                        type = type.MakePointerType();
                    
                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.ByRef)
                        type = type.MakeByRefType();
 
                    else if ((CorElementType)Marshal.ReadInt32((IntPtr)arModifiers, i * sizeof(int)) == CorElementType.SzArray)
                        type = type.MakeArrayType();
 
                    else
                        type = type.MakeArrayType(Marshal.ReadInt32((IntPtr)arModifiers, ++i * sizeof(int)));
                }
            }
            
            return type;
        }
 
        public static bool operator ==(RuntimeTypeHandle left, object right) { return left.Equals(right); }
        
        public static bool operator ==(object left, RuntimeTypeHandle right) { return right.Equals(left); }
        
        public static bool operator !=(RuntimeTypeHandle left, object right) { return !left.Equals(right); }
 
        public static bool operator !=(object left, RuntimeTypeHandle right) { return !right.Equals(left); }
 
        internal static RuntimeTypeHandle EmptyHandle
        {
            get
            {
                return new RuntimeTypeHandle(null);
            }
        }
        
 
        // This is the RuntimeType for the type
        private RuntimeType m_type;
 
        public override int GetHashCode()
        {
            return m_type != null ? m_type.GetHashCode() : 0;
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override bool Equals(object obj)
        {
            if(!(obj is RuntimeTypeHandle))
                return false;
 
            RuntimeTypeHandle handle =(RuntimeTypeHandle)obj;
            return handle.m_type == m_type;
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public bool Equals(RuntimeTypeHandle handle)
        {
            return handle.m_type == m_type;
        }
 
        public IntPtr Value
        {
#if !FEATURE_LEGACYNETCF
            [SecurityCritical]
#endif
            get
            {
                return m_type != null ? m_type.m_handle : IntPtr.Zero;
            }
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal static extern IntPtr GetValueInternal(RuntimeTypeHandle handle);
 
        internal RuntimeTypeHandle(RuntimeType type)
        {
            m_type = type;
        }
 
        internal bool IsNullHandle() 
        {
            return m_type == null; 
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsPrimitive(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
            return (corElemType >= CorElementType.Boolean && corElemType <= CorElementType.R8) ||
                    corElemType == CorElementType.I ||
                    corElemType == CorElementType.U;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsByRef(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
            return (corElemType == CorElementType.ByRef);
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsPointer(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
            return (corElemType == CorElementType.Ptr);
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsArray(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
            return (corElemType == CorElementType.Array || corElemType == CorElementType.SzArray);
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsSzArray(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
            return (corElemType == CorElementType.SzArray);
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool HasElementType(RuntimeType type)
        {
            CorElementType corElemType = GetCorElementType(type);
 
            return ((corElemType == CorElementType.Array || corElemType == CorElementType.SzArray) // IsArray
                   || (corElemType == CorElementType.Ptr)                                          // IsPointer
                   || (corElemType == CorElementType.ByRef));                                      // IsByRef
        }
 
        [SecurityCritical]
        internal static IntPtr[] CopyRuntimeTypeHandles(RuntimeTypeHandle[] inHandles, out int length)
        {
            if (inHandles == null || inHandles.Length == 0)
            {
                length = 0;
                return null;
            }
 
            IntPtr[] outHandles = new IntPtr[inHandles.Length];
            for (int i = 0; i < inHandles.Length; i++)
            {
                outHandles[i] = inHandles[i].Value;
            }
            length = outHandles.Length;
            return outHandles;
        }
 
        [SecurityCritical]
        internal static IntPtr[] CopyRuntimeTypeHandles(Type[] inHandles, out int length)
        {
            if (inHandles == null || inHandles.Length == 0)
            {
                length = 0;
                return null;
            }
 
            IntPtr[] outHandles = new IntPtr[inHandles.Length];
            for (int i = 0; i < inHandles.Length; i++)
            {
                outHandles[i] = inHandles[i].GetTypeHandleInternal().Value;
            }
            length = outHandles.Length;
            return outHandles;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern Object CreateInstance(RuntimeType type, bool publicOnly, bool noCheck, ref bool canBeCached, ref RuntimeMethodHandleInternal ctor, ref bool bNeedSecurityCheck);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern Object CreateCaInstance(RuntimeType type, IRuntimeMethodInfo ctor);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern Object Allocate(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern Object CreateInstanceForAnotherGenericParameter(RuntimeType type, RuntimeType genericParameter);
        
        internal RuntimeType GetRuntimeType()
        {
            return m_type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static CorElementType GetCorElementType(RuntimeType type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeAssembly GetAssembly(RuntimeType type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        internal extern static RuntimeModule GetModule(RuntimeType type);
 
        [CLSCompliant(false)]
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public ModuleHandle GetModuleHandle()
        {
            return new ModuleHandle(RuntimeTypeHandle.GetModule(m_type));
        }
        
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeType GetBaseType(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static TypeAttributes GetAttributes(RuntimeType type); 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeType GetElementType(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool CompareCanonicalHandles(RuntimeType left, RuntimeType right);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int GetArrayRank(RuntimeType type); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int GetToken(RuntimeType type); 
        
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeMethodHandleInternal GetMethodAt(RuntimeType type, int slot);
 
        // This is managed wrapper for MethodTable::IntroducedMethodIterator
        internal struct IntroducedMethodEnumerator
        {
            bool                    _firstCall;
            RuntimeMethodHandleInternal _handle;
 
            [System.Security.SecuritySafeCritical]  // auto-generated
            internal IntroducedMethodEnumerator(RuntimeType type)
            {
                _handle = RuntimeTypeHandle.GetFirstIntroducedMethod(type);
                _firstCall = true;
            }
        
            [System.Security.SecuritySafeCritical]  // auto-generated
            public bool MoveNext() 
            {
                if (_firstCall)
                {
                    _firstCall = false;
                }
                else if (_handle.Value != IntPtr.Zero)
                {
                    RuntimeTypeHandle.GetNextIntroducedMethod(ref _handle);
                }
                return !(_handle.Value == IntPtr.Zero);
            }
 
            public RuntimeMethodHandleInternal Current
            { 
                get {
                    return _handle;
                }
            }
 
            // Glue to make this work nicely with C# foreach statement
            public IntroducedMethodEnumerator GetEnumerator()
            {
                return this;
            }
        }
 
        internal static IntroducedMethodEnumerator GetIntroducedMethods(RuntimeType type)
        {
            return new IntroducedMethodEnumerator(type);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern RuntimeMethodHandleInternal GetFirstIntroducedMethod(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern void GetNextIntroducedMethod(ref RuntimeMethodHandleInternal method);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool GetFields(RuntimeType type, IntPtr* result, int* count);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.AppDomain)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static Type[] GetInterfaces(RuntimeType type);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetConstraints(RuntimeTypeHandle handle, ObjectHandleOnStack types);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal Type[] GetConstraints()
        {
            Type[] types = null;
            GetConstraints(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types));
 
            return types;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.AppDomain)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static IntPtr GetGCHandle(RuntimeTypeHandle handle, GCHandleType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal IntPtr GetGCHandle(GCHandleType type)
        {
            return GetGCHandle(GetNativeHandle(), type);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int GetNumVirtuals(RuntimeType type); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void VerifyInterfaceIsImplemented(RuntimeTypeHandle handle, RuntimeTypeHandle interfaceHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal void VerifyInterfaceIsImplemented(RuntimeTypeHandle interfaceHandle)
        {
            VerifyInterfaceIsImplemented(GetNativeHandle(), interfaceHandle.GetNativeHandle());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static int GetInterfaceMethodImplementationSlot(RuntimeTypeHandle handle, RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [ResourceConsumption(ResourceScope.AppDomain, ResourceScope.AppDomain)]
        internal int GetInterfaceMethodImplementationSlot(RuntimeTypeHandle interfaceHandle, RuntimeMethodHandleInternal interfaceMethodHandle)
        {
            return GetInterfaceMethodImplementationSlot(GetNativeHandle(), interfaceHandle.GetNativeHandle(), interfaceMethodHandle);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsComObject(RuntimeType type, bool isGenericCOM); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsContextful(RuntimeType type); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsInterface(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private extern static bool _IsVisible(RuntimeTypeHandle typeHandle);
        
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsVisible(RuntimeType type)
        {
            return _IsVisible(new RuntimeTypeHandle(type));
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecurityCritical(RuntimeTypeHandle typeHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecurityCritical()
        {
            return IsSecurityCritical(GetNativeHandle());
        }
 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecuritySafeCritical(RuntimeTypeHandle typeHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecuritySafeCritical()
        {
            return IsSecuritySafeCritical(GetNativeHandle());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecurityTransparent(RuntimeTypeHandle typeHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecurityTransparent()
        {
            return IsSecurityTransparent(GetNativeHandle());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool HasProxyAttribute(RuntimeType type);
 
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsValueType(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void ConstructName(RuntimeTypeHandle handle, TypeNameFormatFlags formatFlags, StringHandleOnStack retString);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal string ConstructName(TypeNameFormatFlags formatFlags)
        {
            string name = null;
            ConstructName(GetNativeHandle(), formatFlags, JitHelpers.GetStringHandleOnStack(ref name));
            return name;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static void* _GetUtf8Name(RuntimeType type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static Utf8String GetUtf8Name(RuntimeType type)
        {
            return new Utf8String(_GetUtf8Name(type));
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool CanCastTo(RuntimeType type, RuntimeType target);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeType GetDeclaringType(RuntimeType type);
        
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static IRuntimeMethodInfo GetDeclaringMethod(RuntimeType type);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetDefaultConstructor(RuntimeTypeHandle handle, ObjectHandleOnStack method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal IRuntimeMethodInfo GetDefaultConstructor()       
        {
            IRuntimeMethodInfo ctor = null;
            GetDefaultConstructor(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref ctor));
            return ctor;
        }
       
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, StackCrawlMarkHandle stackMark, 
#if FEATURE_HOSTED_BINDER
            IntPtr pPrivHostBinder,
#endif
            bool loadTypeFromPartialName, ObjectHandleOnStack type);
 
#if FEATURE_HOSTED_BINDER
        // Wrapper function to reduce the need for ifdefs.
        internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark, bool loadTypeFromPartialName)
        {
            return GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly, ref stackMark, IntPtr.Zero, loadTypeFromPartialName);
        }
#endif
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetTypeByName(string name, bool throwOnError, bool ignoreCase, bool reflectionOnly, ref StackCrawlMark stackMark,
#if FEATURE_HOSTED_BINDER
                                                  IntPtr pPrivHostBinder,
#endif
                                                  bool loadTypeFromPartialName)
        {
            if (name == null || name.Length == 0)
            {
                if (throwOnError)
                    throw new TypeLoadException(Environment.GetResourceString("Arg_TypeLoadNullStr"));
 
                return null;
            }
 
            RuntimeType type = null;
 
            GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly,
                JitHelpers.GetStackCrawlMarkHandle(ref stackMark),
#if FEATURE_HOSTED_BINDER
                pPrivHostBinder,
#endif
                loadTypeFromPartialName, JitHelpers.GetObjectHandleOnStack(ref type));
 
            return type;
        }
 
        internal static Type GetTypeByName(string name, ref StackCrawlMark stackMark)
        {
            return GetTypeByName(name, false, false, false, ref stackMark, false);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetTypeByNameUsingCARules(string name, RuntimeModule scope)
        {
            if (name == null || name.Length == 0)
                throw new ArgumentException("name"); 
            Contract.EndContractBlock();
 
            RuntimeType type = null;
            GetTypeByNameUsingCARules(name, scope.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
 
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static void GetInstantiation(RuntimeTypeHandle type, ObjectHandleOnStack types, bool fAsRuntimeTypeArray);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal RuntimeType[] GetInstantiationInternal()
        {
            RuntimeType[] types = null;
            GetInstantiation(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types), true);
            return types;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal Type[] GetInstantiationPublic()
        {
            Type[] types = null;
            GetInstantiation(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref types), false);
            return types;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void Instantiate(RuntimeTypeHandle handle, IntPtr* pInst, int numGenericArgs, ObjectHandleOnStack type);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal RuntimeType Instantiate(Type[] inst)
        {
            // defensive copy to be sure array is not mutated from the outside during processing
            int instCount;
            IntPtr []instHandles = CopyRuntimeTypeHandles(inst, out instCount);
 
            fixed (IntPtr* pInst = instHandles)
            {
                RuntimeType type = null;
                Instantiate(GetNativeHandle(), pInst, instCount, JitHelpers.GetObjectHandleOnStack(ref type));
                GC.KeepAlive(inst);
                return type;
            }
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void MakeArray(RuntimeTypeHandle handle, int rank, ObjectHandleOnStack type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal RuntimeType MakeArray(int rank)
        {
            RuntimeType type = null;
            MakeArray(GetNativeHandle(), rank, JitHelpers.GetObjectHandleOnStack(ref type));
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void MakeSZArray(RuntimeTypeHandle handle, ObjectHandleOnStack type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal RuntimeType MakeSZArray()
        {
            RuntimeType type = null;
            MakeSZArray(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
            return type;
        }
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void MakeByRef(RuntimeTypeHandle handle, ObjectHandleOnStack type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal RuntimeType MakeByRef()
        {
#if FEATURE_LEGACYNETCF
            try {
#endif
                RuntimeType type = null;
                MakeByRef(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
                return type;
#if FEATURE_LEGACYNETCF
            } catch(Exception) {
                if (CompatibilitySwitches.IsAppEarlierThanWindowsPhone8)
                    return null;
                throw;
            }
#endif
        }
       
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void MakePointer(RuntimeTypeHandle handle, ObjectHandleOnStack type);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal RuntimeType MakePointer()
        {
            RuntimeType type = null;
            MakePointer(GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static bool IsCollectible(RuntimeTypeHandle handle);
        
        #if FEATURE_CORECLR
        [System.Security.SecuritySafeCritical] // auto-generated
        #endif
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool HasInstantiation(RuntimeType type);
 
        internal bool HasInstantiation()
        {
            return HasInstantiation(GetTypeChecked());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetGenericTypeDefinition(RuntimeTypeHandle type, ObjectHandleOnStack retType);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetGenericTypeDefinition(RuntimeType type)
        {
            RuntimeType retType = type;
 
            if (HasInstantiation(retType) && !IsGenericTypeDefinition(retType))
                GetGenericTypeDefinition(retType.GetTypeHandleInternal(), JitHelpers.GetObjectHandleOnStack(ref retType));
 
            return retType;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsGenericTypeDefinition(RuntimeType type);
       
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsGenericVariable(RuntimeType type);
 
        internal bool IsGenericVariable()
        {
            return IsGenericVariable(GetTypeChecked());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static int GetGenericVariableIndex(RuntimeType type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal int GetGenericVariableIndex()
        {
            RuntimeType type = GetTypeChecked();
 
            if (!IsGenericVariable(type))
                throw new InvalidOperationException(Environment.GetResourceString("Arg_NotGenericParameter"));
 
            return GetGenericVariableIndex(type);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool ContainsGenericVariables(RuntimeType handle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool ContainsGenericVariables()
        {
            return ContainsGenericVariables(GetTypeChecked());
        }
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static bool SatisfiesConstraints(RuntimeType paramType, IntPtr *pTypeContext, int typeContextLength, IntPtr *pMethodContext, int methodContextLength, RuntimeType toType);
 
        [System.Security.SecurityCritical]
        internal static bool SatisfiesConstraints(RuntimeType paramType, RuntimeType[] typeContext, RuntimeType[] methodContext, RuntimeType toType)
        {
            int typeContextLength;
            int methodContextLength;
            IntPtr[] typeContextHandles = CopyRuntimeTypeHandles(typeContext, out typeContextLength);
            IntPtr[] methodContextHandles = CopyRuntimeTypeHandles(methodContext, out methodContextLength);
            
            fixed (IntPtr *pTypeContextHandles = typeContextHandles, pMethodContextHandles = methodContextHandles)
            {
                bool result = SatisfiesConstraints(paramType, pTypeContextHandles, typeContextLength, pMethodContextHandles, methodContextLength, toType);
 
                GC.KeepAlive(typeContext);
                GC.KeepAlive(methodContext);
 
                return result;
            }
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static IntPtr _GetMetadataImport(RuntimeType type);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static MetadataImport GetMetadataImport(RuntimeType type)
        {
            return new MetadataImport(_GetMetadataImport(type), type);
        }
        
        [System.Security.SecurityCritical]  // auto-generated
        private RuntimeTypeHandle(SerializationInfo info, StreamingContext context)
        {
            if(info == null) 
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
 
            RuntimeType m = (RuntimeType)info.GetValue("TypeObj", typeof(RuntimeType));
 
            m_type = m;
 
            if (m_type == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
        }
 
        [System.Security.SecurityCritical]
        public void GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            if(info == null) 
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
 
            if (m_type == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState")); 
 
            info.AddValue("TypeObj", m_type, typeof(RuntimeType));
        }
 
#if !FEATURE_CORECLR
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal static extern bool IsEquivalentTo(RuntimeType rtType1, RuntimeType rtType2);
 
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal static extern bool IsEquivalentType(RuntimeType type);
#endif // FEATURE_CORECLR
    }
 
    // This type is used to remove the expense of having a managed reference object that is dynamically 
    // created when we can prove that we don't need that object. Use of this type requires code to ensure
    // that the underlying native resource is not freed. 
    // Cases in which this may be used:
    //  1. When native code calls managed code passing one of these as a parameter
    //  2. When managed code acquires one of these from an IRuntimeMethodInfo, and ensure that the IRuntimeMethodInfo is preserved
    //     across the lifetime of the RuntimeMethodHandleInternal instance
    //  3. When another object is used to keep the RuntimeMethodHandleInternal alive. See delegates, CreateInstance cache, Signature structure
    // When in doubt, do not use. 
    internal struct RuntimeMethodHandleInternal
    {
        internal static RuntimeMethodHandleInternal EmptyHandle
        {
            get
            {
                return new RuntimeMethodHandleInternal();
            }
        }
 
        internal bool IsNullHandle()
        {
            return m_handle.IsNull();
        }
 
        internal IntPtr Value
        {
            [SecurityCritical]
            get
            {
                return m_handle;
            }
        }
 
        [SecurityCritical]
        internal RuntimeMethodHandleInternal(IntPtr value)
        {
            m_handle = value;
        }
      
        internal IntPtr m_handle;
    }
 
    internal class RuntimeMethodInfoStub : IRuntimeMethodInfo
    {
        public RuntimeMethodInfoStub(RuntimeMethodHandleInternal methodHandleValue, object keepalive)
        {
            m_keepalive = keepalive;
            m_value = methodHandleValue;
        }
 
        [SecurityCritical]
        public RuntimeMethodInfoStub(IntPtr methodHandleValue, object keepalive)
        {
            m_keepalive = keepalive;
            m_value = new RuntimeMethodHandleInternal(methodHandleValue);
        }
 
        object m_keepalive;
 
        // These unused variables are used to ensure that this class has the same layout as RuntimeMethodInfo
#pragma warning disable 169
        object m_a;
        object m_b;
        object m_c;
        object m_d;
        object m_e;
        object m_f;
        object m_g;
#if FEATURE_REMOTING
        object m_h;
#endif
#pragma warning restore 169
        public RuntimeMethodHandleInternal m_value;
 
        RuntimeMethodHandleInternal IRuntimeMethodInfo.Value
        {
            get
            {
                return m_value;
            }
        }
    }
 
    internal interface IRuntimeMethodInfo
    {
        RuntimeMethodHandleInternal Value
        {
            get;
        }
    }                                       
 
    [Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct RuntimeMethodHandle : ISerializable
    {
        // Returns handle for interop with EE. The handle is guaranteed to be non-null.
        internal static IRuntimeMethodInfo EnsureNonNullMethodInfo(IRuntimeMethodInfo method)
        {
            if (method == null)
                throw new ArgumentNullException(null, Environment.GetResourceString("Arg_InvalidHandle"));
            return method;
        }
 
        internal static RuntimeMethodHandle EmptyHandle
        {
            get { return new RuntimeMethodHandle(); }
        }
 
        private IRuntimeMethodInfo m_value;
        
        internal RuntimeMethodHandle(IRuntimeMethodInfo method)
        {
            m_value = method;
        }
 
        internal IRuntimeMethodInfo GetMethodInfo()
        {
            return m_value;
        }
 
        // Used by EE
        [SecurityCritical]
        private static IntPtr GetValueInternal(RuntimeMethodHandle rmh)
        {
            return rmh.Value;
        }
        
        // ISerializable interface
        [System.Security.SecurityCritical]  // auto-generated
        private RuntimeMethodHandle(SerializationInfo info, StreamingContext context)
        {
            if(info == null)
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
            
            MethodBase m =(MethodBase)info.GetValue("MethodObj", typeof(MethodBase));
 
            m_value = m.MethodHandle.m_value;
 
            if (m_value == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
        }
 
        [System.Security.SecurityCritical]
        public void GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            if (info == null) 
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
 
            if (m_value == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState"));
            
            // This is either a RuntimeMethodInfo or a RuntimeConstructorInfo
            MethodBase methodInfo = RuntimeType.GetMethodBase(m_value);
 
            info.AddValue("MethodObj", methodInfo, typeof(MethodBase));
        }
 
        public IntPtr Value
        {
#if FEATURE_LEGACYNETCF
            [SecuritySafeCritical]
#else
            [SecurityCritical]
#endif
            get
            {
                return m_value != null ? m_value.Value.Value : IntPtr.Zero;
            }
        }
 
        [SecuritySafeCritical]
        public override int GetHashCode()
        {
            return ValueType.GetHashCodeOfPtr(Value);
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public override bool Equals(object obj)
        {
            if (!(obj is RuntimeMethodHandle))
                return false;
 
            RuntimeMethodHandle handle = (RuntimeMethodHandle)obj;
 
            return handle.Value == Value;
        }
 
        public static bool operator ==(RuntimeMethodHandle left, RuntimeMethodHandle right)
        {
            return left.Equals(right);
        }
 
        public static bool operator !=(RuntimeMethodHandle left, RuntimeMethodHandle right)
        {
            return !left.Equals(right);
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public bool Equals(RuntimeMethodHandle handle)
        {
            return handle.Value == Value;
        }
 
        [Pure]
        internal bool IsNullHandle() 
        { 
            return m_value == null; 
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static IntPtr GetFunctionPointer(RuntimeMethodHandleInternal handle);
 
        [System.Security.SecurityCritical]  // auto-generated
        public IntPtr GetFunctionPointer()
        {
            IntPtr ptr = GetFunctionPointer(EnsureNonNullMethodInfo(m_value).Value);
            GC.KeepAlive(m_value);
            return ptr;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal unsafe extern static void CheckLinktimeDemands(IRuntimeMethodInfo method, RuntimeModule module, bool isDecoratedTargetSecurityTransparent);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static bool IsCAVisibleFromDecoratedType(
            RuntimeTypeHandle attrTypeHandle,
            IRuntimeMethodInfo attrCtor,
            RuntimeTypeHandle sourceTypeHandle,
            RuntimeModule sourceModule);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private static extern IRuntimeMethodInfo _GetCurrentMethod(ref StackCrawlMark stackMark);
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static IRuntimeMethodInfo GetCurrentMethod(ref StackCrawlMark stackMark)
        {
            return _GetCurrentMethod(ref stackMark);
        }
        
        [Pure]
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern MethodAttributes GetAttributes(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static MethodAttributes GetAttributes(IRuntimeMethodInfo method)
        {
            MethodAttributes retVal = RuntimeMethodHandle.GetAttributes(method.Value);
            GC.KeepAlive(method);
            return retVal;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern MethodImplAttributes GetImplAttributes(IRuntimeMethodInfo method);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format, StringHandleOnStack retString);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static string ConstructInstantiation(IRuntimeMethodInfo method, TypeNameFormatFlags format)
        {
            string name = null;
            ConstructInstantiation(EnsureNonNullMethodInfo(method), format, JitHelpers.GetStringHandleOnStack(ref name));
            return name;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeType GetDeclaringType(RuntimeMethodHandleInternal method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetDeclaringType(IRuntimeMethodInfo method)
        {
            RuntimeType type = RuntimeMethodHandle.GetDeclaringType(method.Value);
            GC.KeepAlive(method);
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int GetSlot(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static int GetSlot(IRuntimeMethodInfo method)
        {
            Contract.Requires(method != null);
 
            int slot = RuntimeMethodHandle.GetSlot(method.Value);
            GC.KeepAlive(method);
            return slot;
        }
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static int GetMethodDef(IRuntimeMethodInfo method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static string GetName(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static string GetName(IRuntimeMethodInfo method)
        {
            string name = RuntimeMethodHandle.GetName(method.Value);
            GC.KeepAlive(method);
            return name;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static void* _GetUtf8Name(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static Utf8String GetUtf8Name(RuntimeMethodHandleInternal method)
        {
            return new Utf8String(_GetUtf8Name(method));
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool MatchesNameHash(RuntimeMethodHandleInternal method, uint hash);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static object InvokeMethod(object target, object[] arguments, Signature sig, bool constructor);
 
        #region Private Invocation Helpers
        [System.Security.SecurityCritical]  // auto-generated
        internal static INVOCATION_FLAGS GetSecurityFlags(IRuntimeMethodInfo handle)
        {
            return (INVOCATION_FLAGS)RuntimeMethodHandle.GetSpecialSecurityFlags(handle);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        static extern internal uint GetSpecialSecurityFlags(IRuntimeMethodInfo method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        static extern internal void PerformSecurityCheck(Object obj, RuntimeMethodHandleInternal method, RuntimeType parent, uint invocationFlags);
 
        [System.Security.SecurityCritical]
        static internal void PerformSecurityCheck(Object obj, IRuntimeMethodInfo method, RuntimeType parent, uint invocationFlags)
        {
            RuntimeMethodHandle.PerformSecurityCheck(obj, method.Value, parent, invocationFlags);
            GC.KeepAlive(method);
            return;
        }
        #endregion
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [DebuggerStepThroughAttribute]
        [Diagnostics.DebuggerHidden]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal extern static void SerializationInvoke(IRuntimeMethodInfo method,
            Object target, SerializationInfo info, ref StreamingContext context);
 
        // This returns true if the token is SecurityTransparent: 
        // just the token - does not consider including module/type etc.
        [System.Security.SecurityCritical]  // auto-generated
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool _IsTokenSecurityTransparent(RuntimeModule module, int metaDataToken);
        
        #if FEATURE_CORECLR
        [System.Security.SecuritySafeCritical] // auto-generated
        #else
        [System.Security.SecurityCritical]
        #endif
        internal static bool IsTokenSecurityTransparent(Module module, int metaDataToken)
        {
            return _IsTokenSecurityTransparent(module.ModuleHandle.GetRuntimeModule(), metaDataToken);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool _IsSecurityCritical(IRuntimeMethodInfo method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsSecurityCritical(IRuntimeMethodInfo method)
        {
            return _IsSecurityCritical(method);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool _IsSecuritySafeCritical(IRuntimeMethodInfo method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsSecuritySafeCritical(IRuntimeMethodInfo method)
        {
            return _IsSecuritySafeCritical(method);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool _IsSecurityTransparent(IRuntimeMethodInfo method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsSecurityTransparent(IRuntimeMethodInfo method)
        {
            return _IsSecurityTransparent(method);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
		[SuppressUnmanagedCodeSecurity]
        private extern static void GetMethodInstantiation(RuntimeMethodHandleInternal method, ObjectHandleOnStack types, bool fAsRuntimeTypeArray);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType[] GetMethodInstantiationInternal(IRuntimeMethodInfo method)
        {
            RuntimeType[] types = null;
            GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), true);
            GC.KeepAlive(method);
            return types;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType[] GetMethodInstantiationInternal(RuntimeMethodHandleInternal method)
        {
            RuntimeType[] types = null;
            GetMethodInstantiation(method, JitHelpers.GetObjectHandleOnStack(ref types), true);
            return types;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static Type[] GetMethodInstantiationPublic(IRuntimeMethodInfo method)
        {
            RuntimeType[] types = null;
            GetMethodInstantiation(EnsureNonNullMethodInfo(method).Value, JitHelpers.GetObjectHandleOnStack(ref types), false);
            GC.KeepAlive(method);
            return types;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool HasMethodInstantiation(RuntimeMethodHandleInternal method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool HasMethodInstantiation(IRuntimeMethodInfo method)
        {
            bool fRet = RuntimeMethodHandle.HasMethodInstantiation(method.Value);
            GC.KeepAlive(method);
            return fRet;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeMethodHandleInternal GetStubIfNeeded(RuntimeMethodHandleInternal method, RuntimeType declaringType, RuntimeType[] methodInstantiation);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static RuntimeMethodHandleInternal GetMethodFromCanonical(RuntimeMethodHandleInternal method, RuntimeType declaringType);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsGenericMethodDefinition(RuntimeMethodHandleInternal method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static bool IsGenericMethodDefinition(IRuntimeMethodInfo method)
        {
            bool fRet = RuntimeMethodHandle.IsGenericMethodDefinition(method.Value);
            GC.KeepAlive(method);
            return fRet;
        }
 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsTypicalMethodDefinition(IRuntimeMethodInfo method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetTypicalMethodDefinition(IRuntimeMethodInfo method, ObjectHandleOnStack outMethod);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static IRuntimeMethodInfo GetTypicalMethodDefinition(IRuntimeMethodInfo method)
        {
            if (!IsTypicalMethodDefinition(method))
                GetTypicalMethodDefinition(method, JitHelpers.GetObjectHandleOnStack(ref method));
 
            return method;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void StripMethodInstantiation(IRuntimeMethodInfo method, ObjectHandleOnStack outMethod);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static IRuntimeMethodInfo StripMethodInstantiation(IRuntimeMethodInfo method)
        {
            IRuntimeMethodInfo strippedMethod = method;
 
            StripMethodInstantiation(method, JitHelpers.GetObjectHandleOnStack(ref strippedMethod));
 
            return strippedMethod;
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static bool IsDynamicMethod(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static void Destroy(RuntimeMethodHandleInternal method);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern static Resolver GetResolver(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private static extern void GetCallerType(StackCrawlMarkHandle stackMark, ObjectHandleOnStack retType);
    
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetCallerType(ref StackCrawlMark stackMark)
        {
            RuntimeType type = null;
            GetCallerType(JitHelpers.GetStackCrawlMarkHandle(ref stackMark), JitHelpers.GetObjectHandleOnStack(ref type));
            return type;
        }
 
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal extern static MethodBody GetMethodBody(IRuntimeMethodInfo method, RuntimeType declaringType);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal extern static bool IsConstructor(RuntimeMethodHandleInternal method);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImpl(MethodImplOptions.InternalCall)]
        internal extern static LoaderAllocator GetLoaderAllocator(RuntimeMethodHandleInternal method);
    }
 
    // This type is used to remove the expense of having a managed reference object that is dynamically 
    // created when we can prove that we don't need that object. Use of this type requires code to ensure
    // that the underlying native resource is not freed. 
    // Cases in which this may be used:
    //  1. When native code calls managed code passing one of these as a parameter
    //  2. When managed code acquires one of these from an RtFieldInfo, and ensure that the RtFieldInfo is preserved
    //     across the lifetime of the RuntimeFieldHandleInternal instance
    //  3. When another object is used to keep the RuntimeFieldHandleInternal alive.
    // When in doubt, do not use. 
    internal struct RuntimeFieldHandleInternal
    {
        internal static RuntimeFieldHandleInternal EmptyHandle
        {
            get
            {
                return new RuntimeFieldHandleInternal();
            }
        }
 
        internal bool IsNullHandle()
        {
            return m_handle.IsNull();
        }
 
        internal IntPtr Value
        {
            [SecurityCritical]
            get
            {
                return m_handle;
            }
        }
 
        [SecurityCritical]
        internal RuntimeFieldHandleInternal(IntPtr value)
        {
            m_handle = value;
        }
 
        internal IntPtr m_handle;
    }
 
    internal interface IRuntimeFieldInfo
    {
        RuntimeFieldHandleInternal Value
        {
            get;
        }
    }
 
    [StructLayout(LayoutKind.Sequential)]
    internal class RuntimeFieldInfoStub : IRuntimeFieldInfo
    {
        [SecuritySafeCritical]
        public RuntimeFieldInfoStub(IntPtr methodHandleValue, object keepalive)
        {
            m_keepalive = keepalive;
            m_fieldHandle = new RuntimeFieldHandleInternal(methodHandleValue);
        }
 
        // These unused variables are used to ensure that this class has the same layout as RuntimeFieldInfo
#pragma warning disable 169
        object m_keepalive;
        object m_c;
        object m_d;
        int m_b;
        object m_e;
#if FEATURE_REMOTING
        object m_f;
#endif
        RuntimeFieldHandleInternal m_fieldHandle;
#pragma warning restore 169
 
        RuntimeFieldHandleInternal IRuntimeFieldInfo.Value
        {
            get
            {
                return m_fieldHandle;
            }
        }
    }
 
    [Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct RuntimeFieldHandle : ISerializable
    {
        // Returns handle for interop with EE. The handle is guaranteed to be non-null.
        internal RuntimeFieldHandle GetNativeHandle()
        {
            // Create local copy to avoid ----s
            IRuntimeFieldInfo field = m_ptr;
            if (field == null)
                throw new ArgumentNullException(null, Environment.GetResourceString("Arg_InvalidHandle"));
            return new RuntimeFieldHandle(field);
        }
 
        private IRuntimeFieldInfo m_ptr;
 
        internal RuntimeFieldHandle(IRuntimeFieldInfo fieldInfo)
        {
            m_ptr = fieldInfo;
        }
 
        internal IRuntimeFieldInfo GetRuntimeFieldInfo()
        {
            return m_ptr;
        }
 
        public IntPtr Value
        {
#if FEATURE_LEGACYNETCF
            [SecuritySafeCritical]
#else
            [SecurityCritical]
#endif
            get
            {
                return m_ptr != null ? m_ptr.Value.Value : IntPtr.Zero;
            }
        }
 
        internal bool IsNullHandle() 
        {
            return m_ptr == null; 
        }
 
        [SecuritySafeCritical]
        public override int GetHashCode()
        {
            return ValueType.GetHashCodeOfPtr(Value);
        }
        
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public override bool Equals(object obj)
        {
            if (!(obj is RuntimeFieldHandle))
                return false;
 
            RuntimeFieldHandle handle = (RuntimeFieldHandle)obj;
 
            return handle.Value == Value;
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        [SecuritySafeCritical]
        public unsafe bool Equals(RuntimeFieldHandle handle)
        {
            return handle.Value == Value;
        }
 
        public static bool operator ==(RuntimeFieldHandle left, RuntimeFieldHandle right)
        {
            return left.Equals(right);
        }
 
        public static bool operator !=(RuntimeFieldHandle left, RuntimeFieldHandle right)
        {
            return !left.Equals(right);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal static extern String GetName(RtFieldInfo field); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        private static extern unsafe void* _GetUtf8Name(RuntimeFieldHandleInternal field); 
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static unsafe Utf8String GetUtf8Name(RuntimeFieldHandleInternal field) { return new Utf8String(_GetUtf8Name(field)); }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool MatchesNameHash(RuntimeFieldHandleInternal handle, uint hash);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern FieldAttributes GetAttributes(RuntimeFieldHandleInternal field); 
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern RuntimeType GetApproxDeclaringType(RuntimeFieldHandleInternal field);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static RuntimeType GetApproxDeclaringType(IRuntimeFieldInfo field)
        {
            RuntimeType type = GetApproxDeclaringType(field.Value);
            GC.KeepAlive(field);
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal static extern int GetToken(RtFieldInfo field); 
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal static extern Object GetValue(RtFieldInfo field, Object instance, RuntimeType fieldType, RuntimeType declaringType, ref bool domainInitialized);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal static extern Object GetValueDirect(RtFieldInfo field, RuntimeType fieldType, void *pTypedRef, RuntimeType contextType);
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        internal static extern void SetValue(RtFieldInfo field, Object obj, Object value, RuntimeType fieldType, FieldAttributes fieldAttr, RuntimeType declaringType, ref bool domainInitialized);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, Object value, RuntimeType contextType);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern RuntimeFieldHandleInternal GetStaticFieldForGenericType(RuntimeFieldHandleInternal field, RuntimeType declaringType);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool AcquiresContextFromThis(RuntimeFieldHandleInternal field);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecurityCritical(RuntimeFieldHandle fieldHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecurityCritical()
        {
            return IsSecurityCritical(GetNativeHandle());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecuritySafeCritical(RuntimeFieldHandle fieldHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecuritySafeCritical()
        {
            return IsSecuritySafeCritical(GetNativeHandle());
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        [return: MarshalAs(UnmanagedType.Bool)]
        private static extern bool IsSecurityTransparent(RuntimeFieldHandle fieldHandle);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal bool IsSecurityTransparent()
        {
            return IsSecurityTransparent(GetNativeHandle());
        }
 
        [SecurityCritical]
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);
 
        // ISerializable interface
        [System.Security.SecurityCritical]  // auto-generated
        private RuntimeFieldHandle(SerializationInfo info, StreamingContext context)
        {
            if(info==null)
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
            
            FieldInfo f =(RuntimeFieldInfo) info.GetValue("FieldObj", typeof(RuntimeFieldInfo));
            
            if( f == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
 
            m_ptr = f.FieldHandle.m_ptr;
 
            if (m_ptr == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InsufficientState"));
        }
 
        [System.Security.SecurityCritical]
        public void GetObjectData(SerializationInfo info, StreamingContext context) 
        {
            if (info == null) 
                throw new ArgumentNullException("info");
            Contract.EndContractBlock();
 
            if (m_ptr == null)
                throw new SerializationException(Environment.GetResourceString("Serialization_InvalidFieldState"));
 
            RuntimeFieldInfo fldInfo = (RuntimeFieldInfo)RuntimeType.GetFieldInfo(this.GetRuntimeFieldInfo()); 
            
            info.AddValue("FieldObj",fldInfo, typeof(RuntimeFieldInfo));
        }
    }
 
[System.Runtime.InteropServices.ComVisible(true)]
    public unsafe struct ModuleHandle
    {
        // Returns handle for interop with EE. The handle is guaranteed to be non-null.
        #region Public Static Members
        public static readonly ModuleHandle EmptyHandle = GetEmptyMH();
        #endregion
 
        unsafe static private ModuleHandle GetEmptyMH()
        {
            return new ModuleHandle();
        }
 
        #region Private Data Members
        private RuntimeModule m_ptr;
        #endregion
    
        #region Constructor
        internal ModuleHandle(RuntimeModule module) 
        {
            m_ptr = module;
        }
        #endregion
 
        #region Internal FCalls
 
        internal RuntimeModule GetRuntimeModule()
        {
            return m_ptr;
        }
 
        internal bool IsNullHandle() 
        { 
            return m_ptr == null; 
        }
        
        public override int GetHashCode()
        {           
            return m_ptr != null ? m_ptr.GetHashCode() : 0;
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public override bool Equals(object obj)
        {
            if (!(obj is ModuleHandle))
                return false;
 
            ModuleHandle handle = (ModuleHandle)obj;
 
            return handle.m_ptr == m_ptr;
        }
 
        [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
        public unsafe bool Equals(ModuleHandle handle)
        {
            return handle.m_ptr == m_ptr;
        }
 
        public static bool operator ==(ModuleHandle left, ModuleHandle right)
        {
            return left.Equals(right);
        }
 
        public static bool operator !=(ModuleHandle left, ModuleHandle right)
        {
            return !left.Equals(right);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern IRuntimeMethodInfo GetDynamicMethod(DynamicMethod method, RuntimeModule module, string name, byte[] sig, Resolver resolver);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern int GetToken(RuntimeModule module);
 
        private static void ValidateModulePointer(RuntimeModule module)
        {
            // Make sure we have a valid Module to resolve against.
            if (module == null)
                throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullModuleHandle"));
        }
 
        // SQL-CLR LKG9 Compiler dependency
        public RuntimeTypeHandle GetRuntimeTypeHandleFromMetadataToken(int typeToken) { return ResolveTypeHandle(typeToken); }
        public RuntimeTypeHandle ResolveTypeHandle(int typeToken) 
        {
            return new RuntimeTypeHandle(ResolveTypeHandleInternal(GetRuntimeModule(), typeToken, null, null));
        }
        public RuntimeTypeHandle ResolveTypeHandle(int typeToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext) 
        {
            return new RuntimeTypeHandle(ModuleHandle.ResolveTypeHandleInternal(GetRuntimeModule(), typeToken, typeInstantiationContext, methodInstantiationContext));
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType ResolveTypeHandleInternal(RuntimeModule module, int typeToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        {
            ValidateModulePointer(module);
            if (!ModuleHandle.GetMetadataImport(module).IsValidToken(typeToken))
                throw new ArgumentOutOfRangeException("metadataToken",
                    Environment.GetResourceString("Argument_InvalidToken", typeToken, new ModuleHandle(module)));
            
            int typeInstCount, methodInstCount;
            IntPtr[] typeInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out typeInstCount);
            IntPtr[] methodInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out methodInstCount);
 
            fixed (IntPtr* typeInstArgs = typeInstantiationContextHandles, methodInstArgs = methodInstantiationContextHandles)
            {
                RuntimeType type = null;
                ResolveType(module, typeToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref type));
                GC.KeepAlive(typeInstantiationContext);
                GC.KeepAlive(methodInstantiationContext);
                return type;
            }
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void ResolveType(RuntimeModule module,
                                                            int typeToken,
                                                            IntPtr* typeInstArgs, 
                                                            int typeInstCount,
                                                            IntPtr* methodInstArgs,
                                                            int methodInstCount,
                                                            ObjectHandleOnStack type);
 
        // SQL-CLR LKG9 Compiler dependency
        public RuntimeMethodHandle GetRuntimeMethodHandleFromMetadataToken(int methodToken) { return ResolveMethodHandle(methodToken); }
        public RuntimeMethodHandle ResolveMethodHandle(int methodToken) { return ResolveMethodHandle(methodToken, null, null); }
        internal static IRuntimeMethodInfo ResolveMethodHandleInternal(RuntimeModule module, int methodToken) { return ModuleHandle.ResolveMethodHandleInternal(module, methodToken, null, null); }
        public RuntimeMethodHandle ResolveMethodHandle(int methodToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        {
            return new RuntimeMethodHandle(ResolveMethodHandleInternal(GetRuntimeModule(), methodToken, typeInstantiationContext, methodInstantiationContext));
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static IRuntimeMethodInfo ResolveMethodHandleInternal(RuntimeModule module, int methodToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        {
            int typeInstCount, methodInstCount;
 
            IntPtr[] typeInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out typeInstCount);
            IntPtr[] methodInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out methodInstCount);
 
            RuntimeMethodHandleInternal handle = ResolveMethodHandleInternalCore(module, methodToken, typeInstantiationContextHandles, typeInstCount, methodInstantiationContextHandles, methodInstCount);
            IRuntimeMethodInfo retVal = new RuntimeMethodInfoStub(handle, RuntimeMethodHandle.GetLoaderAllocator(handle));
            GC.KeepAlive(typeInstantiationContext);
            GC.KeepAlive(methodInstantiationContext);
            return retVal;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static RuntimeMethodHandleInternal ResolveMethodHandleInternalCore(RuntimeModule module, int methodToken, IntPtr[] typeInstantiationContext, int typeInstCount, IntPtr[] methodInstantiationContext, int methodInstCount)
        {
            ValidateModulePointer(module);
            if (!ModuleHandle.GetMetadataImport(module.GetNativeHandle()).IsValidToken(methodToken))
                throw new ArgumentOutOfRangeException("metadataToken",
                    Environment.GetResourceString("Argument_InvalidToken", methodToken, new ModuleHandle(module)));
 
            fixed (IntPtr* typeInstArgs = typeInstantiationContext, methodInstArgs = methodInstantiationContext)
            {
                return ResolveMethod(module.GetNativeHandle(), methodToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount);
            }
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static RuntimeMethodHandleInternal ResolveMethod(RuntimeModule module,
                                                        int methodToken,
                                                        IntPtr* typeInstArgs, 
                                                        int typeInstCount,
                                                        IntPtr* methodInstArgs,
                                                        int methodInstCount);
 
        // SQL-CLR LKG9 Compiler dependency
        public RuntimeFieldHandle GetRuntimeFieldHandleFromMetadataToken(int fieldToken) { return ResolveFieldHandle(fieldToken); }
        public RuntimeFieldHandle ResolveFieldHandle(int fieldToken) { return new RuntimeFieldHandle(ResolveFieldHandleInternal(GetRuntimeModule(), fieldToken, null, null)); }
        public RuntimeFieldHandle ResolveFieldHandle(int fieldToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
            { return new RuntimeFieldHandle(ResolveFieldHandleInternal(GetRuntimeModule(), fieldToken, typeInstantiationContext, methodInstantiationContext)); }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static IRuntimeFieldInfo ResolveFieldHandleInternal(RuntimeModule module, int fieldToken, RuntimeTypeHandle[] typeInstantiationContext, RuntimeTypeHandle[] methodInstantiationContext)
        {
            ValidateModulePointer(module);
            if (!ModuleHandle.GetMetadataImport(module.GetNativeHandle()).IsValidToken(fieldToken))
                throw new ArgumentOutOfRangeException("metadataToken",
                    Environment.GetResourceString("Argument_InvalidToken", fieldToken, new ModuleHandle(module)));
            
            // defensive copy to be sure array is not mutated from the outside during processing
            int typeInstCount, methodInstCount;
            IntPtr [] typeInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(typeInstantiationContext, out typeInstCount);
            IntPtr [] methodInstantiationContextHandles = RuntimeTypeHandle.CopyRuntimeTypeHandles(methodInstantiationContext, out methodInstCount);
 
            fixed (IntPtr* typeInstArgs = typeInstantiationContextHandles, methodInstArgs = methodInstantiationContextHandles)
            {
                IRuntimeFieldInfo field = null;
                ResolveField(module.GetNativeHandle(), fieldToken, typeInstArgs, typeInstCount, methodInstArgs, methodInstCount, JitHelpers.GetObjectHandleOnStack(ref field));
                GC.KeepAlive(typeInstantiationContext);
                GC.KeepAlive(methodInstantiationContext);
                return field;
            }
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void ResolveField(RuntimeModule module,
                                                      int fieldToken,
                                                      IntPtr* typeInstArgs, 
                                                      int typeInstCount,
                                                      IntPtr* methodInstArgs,
                                                      int methodInstCount,
                                                      ObjectHandleOnStack retField);
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static bool _ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static bool ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash)
        {
            return _ContainsPropertyMatchingHash(module.GetNativeHandle(), propertyToken, hash);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetAssembly(RuntimeModule handle, ObjectHandleOnStack retAssembly);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeAssembly GetAssembly(RuntimeModule module)
        {
            RuntimeAssembly retAssembly = null;
            GetAssembly(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref retAssembly));
            return retAssembly;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        internal extern static void GetModuleType(RuntimeModule handle, ObjectHandleOnStack type);
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static RuntimeType GetModuleType(RuntimeModule module)
        {
            RuntimeType type = null;
            GetModuleType(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
            return type;
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
        [SuppressUnmanagedCodeSecurity]
        private extern static void GetPEKind(RuntimeModule handle, out int peKind, out int machine);
   
        // making this internal, used by Module.GetPEKind
        [System.Security.SecuritySafeCritical]  // auto-generated
        internal static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
        {
            int lKind, lMachine;
            GetPEKind(module.GetNativeHandle(), out lKind, out lMachine);
            peKind = (PortableExecutableKinds)lKind;
            machine = (ImageFileMachine)lMachine;
        }
   
        [System.Security.SecurityCritical]  // auto-generated
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        [ResourceExposure(ResourceScope.None)]
        internal extern static int GetMDStreamVersion(RuntimeModule module);
 
        public int MDStreamVersion
        {
            [System.Security.SecuritySafeCritical]  // auto-generated
            get { return GetMDStreamVersion(GetRuntimeModule().GetNativeHandle()); }
        }
        
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        private extern static IntPtr _GetMetadataImport(RuntimeModule module);
 
        [System.Security.SecurityCritical]  // auto-generated
        internal static MetadataImport GetMetadataImport(RuntimeModule module)
        {
            return new MetadataImport(_GetMetadataImport(module.GetNativeHandle()), module);
        }
        #endregion
    }
 
    internal unsafe class Signature
    {
        #region Definitions
        internal enum MdSigCallingConvention : byte
        {
            Generics            = 0x10,
            HasThis             = 0x20,
            ExplicitThis        = 0x40,
            CallConvMask        = 0x0F,
            Default             = 0x00,
            C                   = 0x01,
            StdCall             = 0x02,
            ThisCall            = 0x03,
            FastCall            = 0x04,
            Vararg              = 0x05,
            Field               = 0x06,
            LocalSig            = 0x07,
            Property            = 0x08,
            Unmgd               = 0x09,
            GenericInst         = 0x0A,
            Max                 = 0x0B,
        }
        #endregion
 
        #region FCalls
        [System.Security.SecurityCritical]  // auto-generated
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]        
        private extern void GetSignature(
            void* pCorSig, int cCorSig,
            RuntimeFieldHandleInternal fieldHandle, IRuntimeMethodInfo methodHandle, RuntimeType declaringType);
 
        #endregion
 
        #region Private Data Members
        //
        // Keep the layout in sync with SignatureNative in the VM
        //
        internal RuntimeType[] m_arguments;
        internal RuntimeType m_declaringType;
        internal RuntimeType m_returnTypeORfieldType;
        internal object m_keepalive;
        [SecurityCritical]
        internal void* m_sig;
        internal int m_managedCallingConventionAndArgIteratorFlags; // lowest byte is CallingConvention, upper 3 bytes are ArgIterator flags
        internal int m_nSizeOfArgStack;
        internal int m_csig;
        internal RuntimeMethodHandleInternal m_pMethod;
        #endregion
 
        #region Constructors
        [System.Security.SecuritySafeCritical]  // auto-generated
        public Signature (
            IRuntimeMethodInfo method,
            RuntimeType[] arguments,
            RuntimeType returnType,
            CallingConventions callingConvention)
        {
            m_pMethod = method.Value;
            m_arguments = arguments;
            m_returnTypeORfieldType = returnType;
            m_managedCallingConventionAndArgIteratorFlags = (byte)callingConvention;
 
            GetSignature(null, 0, new RuntimeFieldHandleInternal(), method, null);
        }
 
        [System.Security.SecuritySafeCritical]  // auto-generated
        public Signature(IRuntimeMethodInfo methodHandle, RuntimeType declaringType)
        {
            GetSignature(null, 0, new RuntimeFieldHandleInternal(), methodHandle, declaringType);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        public Signature(IRuntimeFieldInfo fieldHandle, RuntimeType declaringType)
        {
            GetSignature(null, 0, fieldHandle.Value, null, declaringType);
            GC.KeepAlive(fieldHandle);
        }
 
        [System.Security.SecurityCritical]  // auto-generated
        public Signature(void* pCorSig, int cCorSig, RuntimeType declaringType)
        {
            GetSignature(pCorSig, cCorSig, new RuntimeFieldHandleInternal(), null, declaringType);
        }
        #endregion
 
        #region Internal Members
        internal CallingConventions CallingConvention { get { return (CallingConventions)(byte)m_managedCallingConventionAndArgIteratorFlags; } }
        internal RuntimeType[] Arguments { get { return m_arguments; } }
        internal RuntimeType ReturnType { get { return m_returnTypeORfieldType; } }
        internal RuntimeType FieldType { get { return m_returnTypeORfieldType; } }
 
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool CompareSig(Signature sig1, Signature sig2);
 
#if FEATURE_LEGACYNETCF
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal static extern bool CompareSigForAppCompat(Signature left, RuntimeType typeLeft, Signature right, RuntimeType typeRight); 
#endif
 
        [System.Security.SecuritySafeCritical]
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)]
        internal extern Type[] GetCustomModifiers(int position, bool required);
        #endregion
    }
 
 
    internal abstract class Resolver
    {
        internal struct CORINFO_EH_CLAUSE 
        {
            internal int Flags;
            internal int TryOffset;
            internal int TryLength;
            internal int HandlerOffset;
            internal int HandlerLength;
            internal int ClassTokenOrFilterOffset; 
        }
 
        // ILHeader info
        internal abstract RuntimeType GetJitContext(ref int securityControlFlags);
        internal abstract byte[] GetCodeInfo(ref int stackSize, ref int initLocals, ref int EHCount);
        internal abstract byte[] GetLocalsSignature();
        [System.Security.SecurityCritical] // takes a pointer parameter
        internal abstract unsafe void GetEHInfo(int EHNumber, void* exception);
        internal abstract unsafe byte[] GetRawEHInfo();
        // token resolution
        internal abstract String GetStringLiteral(int token);
        [System.Security.SecurityCritical] // passes a pointer out
        internal abstract void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle);
        internal abstract byte[] ResolveSignature(int token, int fromMethod);
        // 
        internal abstract MethodInfo GetDynamicMethod();
#if FEATURE_COMPRESSEDSTACK
        internal abstract CompressedStack GetSecurityContext();
#endif
    }
 
}