private CustomAttributeData(RuntimeModule scope, CustomAttributeRecord caRecord)
 {
     this.m_scope = scope;
     this.m_ctor = (RuntimeConstructorInfo) RuntimeType.GetMethodBase(scope, (int) caRecord.tkCtor);
     ParameterInfo[] parametersNoCopy = this.m_ctor.GetParametersNoCopy();
     this.m_ctorParams = new CustomAttributeCtorParameter[parametersNoCopy.Length];
     for (int i = 0; i < parametersNoCopy.Length; i++)
     {
         this.m_ctorParams[i] = new CustomAttributeCtorParameter(InitCustomAttributeType((RuntimeType) parametersNoCopy[i].ParameterType));
     }
     FieldInfo[] fields = this.m_ctor.DeclaringType.GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     PropertyInfo[] properties = this.m_ctor.DeclaringType.GetProperties(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
     this.m_namedParams = new CustomAttributeNamedParameter[properties.Length + fields.Length];
     for (int j = 0; j < fields.Length; j++)
     {
         this.m_namedParams[j] = new CustomAttributeNamedParameter(fields[j].Name, CustomAttributeEncoding.Field, InitCustomAttributeType((RuntimeType) fields[j].FieldType));
     }
     for (int k = 0; k < properties.Length; k++)
     {
         this.m_namedParams[k + fields.Length] = new CustomAttributeNamedParameter(properties[k].Name, CustomAttributeEncoding.Property, InitCustomAttributeType((RuntimeType) properties[k].PropertyType));
     }
     this.m_members = new MemberInfo[fields.Length + properties.Length];
     fields.CopyTo(this.m_members, 0);
     properties.CopyTo(this.m_members, fields.Length);
     CustomAttributeEncodedArgument.ParseAttributeArguments(caRecord.blob, ref this.m_ctorParams, ref this.m_namedParams, this.m_scope);
 }

		private static void ValidateModulePointer(RuntimeModule module)
		{
			if (module == null)
			{
				throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_NullModuleHandle"));
			}
		}

 [System.Security.SecurityCritical]  // auto-generated
 internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm) { 
     dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, 
                                   module,
                                   m_methodBuilder.Name, 
                                   (byte[])m_scope[m_methodSigToken],
                                   new DynamicResolver(this));
 }

 internal static void ParseAttributeArguments(ConstArray attributeBlob, ref CustomAttributeCtorParameter[] customAttributeCtorParameters, ref CustomAttributeNamedParameter[] customAttributeNamedParameters, RuntimeModule customAttributeModule)
 {
     if (customAttributeModule == null)
     {
         throw new ArgumentNullException("customAttributeModule");
     }
     if ((customAttributeCtorParameters.Length != 0) || (customAttributeNamedParameters.Length != 0))
     {
         ParseAttributeArguments(attributeBlob.Signature, attributeBlob.Length, ref customAttributeCtorParameters, ref customAttributeNamedParameters, (RuntimeAssembly) customAttributeModule.Assembly);
     }
 }

 private extern static void GetTypeByNameUsingCARules(string name, RuntimeModule scope, ObjectHandleOnStack type);

 private extern static IntPtr _GetMetadataImport(RuntimeModule module);

 [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.SecuritySafeCritical]  // auto-generated
 internal static RuntimeType GetModuleType(RuntimeModule module)
 {
     RuntimeType type = null;
     GetModuleType(module.GetNativeHandle(), JitHelpers.GetObjectHandleOnStack(ref type));
     return type;
 }

 [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
 internal static bool ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash)
 {
     return _ContainsPropertyMatchingHash(module.GetNativeHandle(), propertyToken, hash);
 }

 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"));
 }

 internal static extern int GetToken(RuntimeModule module);

 internal static extern IRuntimeMethodInfo GetDynamicMethod(DynamicMethod method, RuntimeModule module, string name, byte[] sig, Resolver resolver);

 internal ModuleHandle(RuntimeModule module) 
 {
     m_ptr = module;
 }

 internal static extern void CheckAttributeAccess(RuntimeFieldHandle fieldHandle, RuntimeModule decoratedTarget);

 private extern static void ResolveField(RuntimeModule module,
                                               int fieldToken,
                                               IntPtr* typeInstArgs, 
                                               int typeInstCount,
                                               IntPtr* methodInstArgs,
                                               int methodInstCount,
                                               ObjectHandleOnStack retField);

 private extern static bool _ContainsPropertyMatchingHash(RuntimeModule module, int propertyToken, uint hash);

        [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;
            }
        }

 private extern static void ResolveType(RuntimeModule module,
                                                     int typeToken,
                                                     IntPtr* typeInstArgs, 
                                                     int typeInstCount,
                                                     IntPtr* methodInstArgs,
                                                     int methodInstCount,
                                                     ObjectHandleOnStack type);

 internal static IRuntimeMethodInfo ResolveMethodHandleInternal(RuntimeModule module, int methodToken) { return ModuleHandle.ResolveMethodHandleInternal(module, methodToken, null, null); }