예제 #1
0
    /*^
    #pragma warning disable 2666, 2669, 2677, 2674
    ^*/
    internal PEFileToObjectModel(
      PeReader peReader,
      PEFileReader peFileReader,
      ModuleIdentity moduleIdentity,
      Assembly/*?*/ containingAssembly,
      byte pointerSize
    )
      //^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null;
      //^ requires peFileReader.IsAssembly ==> containingAssembly == null;
      //^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0);
    {
      this.pointerSize = pointerSize;
      this.document = new MetadataObjectDocument(this);
      this.ModuleReader = peReader;
      this.PEFileReader = peFileReader;
      this.NameTable = peReader.metadataReaderHost.NameTable;
      this.InternFactory = peReader.metadataReaderHost.InternFactory;
      this.StringIndexToNameTable = new Hashtable<IName>();
      this.StringIndexToUnmangledNameTable = new Hashtable<IName>();
      this.typeCache = new TypeCache(this);
      uint moduleNameOffset = peFileReader.ModuleTable.GetName(1);
      IName moduleName = this.GetNameFromOffset(moduleNameOffset);
      AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity;
      if (peFileReader.IsAssembly) {
        //^ assert assemblyIdentity != null;
        AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
        IName assemblyName = this.GetNameFromOffset(assemblyRow.Name);
        byte[] publicKeyArray = TypeCache.EmptyByteArray;
        if (assemblyRow.PublicKey != 0) {
          publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
        }
        uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity);
        Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray);
        this.ContainingAssembly = assem;
        this.Module = assem;
      } else {
        uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity);
        this.ContainingAssembly = containingAssembly;
        this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity);
      }

      this.LoadAssemblyReferences();
      this.LoadModuleReferences();
      this.RootModuleNamespace = new RootNamespace(this);
      this.NamespaceINameHashtable = new Hashtable<Namespace>();
      this.LoadNamespaces();
      this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>();
      this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
      this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
      this.PreLoadTypeDefTableLookup();
      this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
      this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1];
      this.RedirectedTypeDefArray = new INamedTypeReference/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
      this.ModuleTypeDefLoadState[0] = LoadState.Loaded;

      this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1];
      this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1];
      this.ExportedTypeLoadState[0] = LoadState.Loaded;

      this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1];
      if (peFileReader.MethodSpecTable.NumberOfRows > 0) {
        this.ModuleMethodSpecHashtable = new DoubleHashtable<IGenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1);
      }

      this.ModuleTypeRefReferenceArray = new INamedTypeReference[peFileReader.TypeRefTable.NumberOfRows + 1];
      this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1];
      this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded;
      if (peFileReader.TypeSpecTable.NumberOfRows > 0) {
        this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1);
      }

      this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1];
      this.ModuleMethodArray = new IMethodDefinition[peFileReader.MethodTable.NumberOfRows + 1];
      this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1];
      this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1];

      this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];
      this.UnspecializedMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];
      this.SpecializedFieldHashtable = new DoubleHashtable<ISpecializedFieldReference>();
      this.SpecializedMethodHashtable = new DoubleHashtable<ISpecializedMethodReference>();

      this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1];

      this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1];

      this._Module_ = this.Create_Module_Type();
    }
예제 #2
0
 /// <summary>
 /// Computes the AssemblyIdentifier of the PE File. This requires that peFile is an assembly.
 /// </summary>
 /// <param name="peFileReader"></param>
 /// <returns></returns>
 internal AssemblyIdentity GetAssemblyIdentifier(PEFileReader peFileReader)
   //^ requires peFileReader.ReaderState >= ReaderState.Metadata && peFileReader.IsAssembly;
   //^ ensures (result.Location != null && result.Location.Length != 0);
 {
   AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
   IName assemblyName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[assemblyRow.Name]);
   string cultureName = peFileReader.StringStream[assemblyRow.Culture];
   Version version = new Version(assemblyRow.MajorVersion, assemblyRow.MinorVersion, assemblyRow.BuildNumber, assemblyRow.RevisionNumber);
   byte[] publicKeyArray = TypeCache.EmptyByteArray;
   byte[] publicKeyTokenArray = TypeCache.EmptyByteArray;
   if (assemblyRow.PublicKey != 0) {
     publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
     if (publicKeyArray.Length > 0) {
       publicKeyTokenArray = UnitHelper.ComputePublicKeyToken(publicKeyArray);
     }
   }
   return new AssemblyIdentity(assemblyName, cultureName, version, publicKeyTokenArray, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location);
 }
예제 #3
0
 /// <summary>
 /// Computes the ModuleIdentifier of the PE File as if the module belong to given assembly.
 /// </summary>
 /// <param name="peFileReader"></param>
 /// <param name="containingAssemblyIdentity"></param>
 /// <returns></returns>
 internal ModuleIdentity GetModuleIdentifier(PEFileReader peFileReader, AssemblyIdentity containingAssemblyIdentity)
   //^ requires peFileReader.ReaderState >= ReaderState.Metadata;
   //^ ensures (result.Location != null && result.Location.Length != 0);
 {
   ModuleRow moduleRow = peFileReader.ModuleTable[1];
   IName moduleName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[moduleRow.Name]);
   return new ModuleIdentity(moduleName, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location, containingAssemblyIdentity);
 }
예제 #4
0
 /// <summary>
 /// Method to open the module in the MetadataReader. This method loads the module and returns the object corresponding to the opened module.
 /// Also returns the ModuleIDentifier corresponding to the module as the out parameter. Modules are opened as if they are not contained in any assembly.
 /// </summary>
 /// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
 /// <param name="moduleIdentity">Contains the module identity of the binary document in case it is an module.</param>
 /// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
 public IModule OpenModule(
   IBinaryDocument binaryDocument,
   out ModuleIdentity/*?*/ moduleIdentity
 ) {
   moduleIdentity = null;
   lock (GlobalLock.LockingObject) {
     IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
     if (binaryDocumentMemoryBlock == null) {
       //  Error...
       return Dummy.Module;
     }
     PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
     if (peFileReader.ReaderState < ReaderState.Metadata) {
       //  Error...
       return Dummy.Module;
     }
     //^ assert peFileReader.ReaderState >= ReaderState.Metadata;
     if (peFileReader.IsAssembly) {
       AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
       moduleIdentity = assemblyIdentity;
       Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
       if (lookupAssembly != null) {
         return lookupAssembly;
       }
     } else {
       moduleIdentity = this.GetModuleIdentifier(peFileReader);
       Module/*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
       if (lookupModule != null) {
         return lookupModule;
       }
     }
     try {
       PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
       this.LoadedModule(peFileToObjectModel.Module);
       Assembly/*?*/ assembly = peFileToObjectModel.Module as Assembly;
       if (assembly != null) {
         this.OpenMemberModules(binaryDocument, assembly);
       }
       return peFileToObjectModel.Module;
     } catch (MetadataReaderException) {
       //  Error...
     }
   }
   return Dummy.Module;
 }
예제 #5
0
 /// <summary>
 /// If the given binary document contains a CLR assembly, return the identity of the assembly. Otherwise, return null.
 /// </summary>
 public AssemblyIdentity/*?*/ GetAssemblyIdentifier(IBinaryDocument binaryDocument) {
   IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
   if (binaryDocumentMemoryBlock == null) return null;
   PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
   if (peFileReader.ReaderState < ReaderState.Metadata) return null;
   if (!peFileReader.IsAssembly) return null;
   return this.GetAssemblyIdentifier(peFileReader);
 }
예제 #6
0
 /// <summary>
 /// Method to open the assembly in MetadataReader. This method loads the assembly and returns the object corresponding to the
 /// opened assembly. Also returns the AssemblyIdentifier corresponding to the assembly as the out parameter.
 /// Only assemblies that unify to themselves can be opened i.e. if the unification policy of the compilation host says that mscorlib 1.0 unifies to mscorlib 2.0
 /// then only mscorlib 2.0 can be loaded.
 /// </summary>
 /// <param name="binaryDocument">The binary document that needes to be opened as an assembly.</param>
 /// <param name="assemblyIdentity">Contains the assembly identifier of the binary document in case it is an assembly.</param>
 /// <returns>Assembly that is loaded or Dummy.Assembly in case assembly could not be loaded.</returns>
 public IAssembly OpenAssembly(
   IBinaryDocument binaryDocument,
   out AssemblyIdentity/*?*/ assemblyIdentity
 ) {
   assemblyIdentity = null;
   lock (GlobalLock.LockingObject) {
     IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
     if (binaryDocumentMemoryBlock == null) {
       //  Error...
       return Dummy.Assembly;
     }
     PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
     if (peFileReader.ReaderState < ReaderState.Metadata) {
       //  Error...
       return Dummy.Assembly;
     }
     //^ assert peFileReader.ReaderState >= ReaderState.Metadata;
     if (!peFileReader.IsAssembly) {
       //  Error...
       return Dummy.Assembly;
     }
     assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
     Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
     if (lookupAssembly != null) {
       return lookupAssembly;
     }
     try {
       PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, assemblyIdentity, null, this.metadataReaderHost.PointerSize);
       Assembly/*?*/ assembly = peFileToObjectModel.Module as Assembly;
       //^ assert assembly != null;
       this.LoadedModule(assembly);
       this.OpenMemberModules(binaryDocument, assembly);
       return assembly;
     } catch (MetadataReaderException) {
       return Dummy.Assembly;
     }
   }
 }
예제 #7
0
 /// <summary>
 /// This method is called when an assembly is loaded. This makes sure that all the member modules of the assembly are loaded.
 /// </summary>
 /// <param name="binaryDocument"></param>
 /// <param name="assembly"></param>
 void OpenMemberModules(IBinaryDocument binaryDocument, Assembly assembly) {
   List<Module> memberModuleList = new List<Module>();
   AssemblyIdentity assemblyIdentity = assembly.AssemblyIdentity;
   foreach (IFileReference fileRef in assembly.PEFileToObjectModel.GetFiles()) {
     if (!fileRef.HasMetadata)
       continue;
     IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument, fileRef.FileName.Value);
     if (binaryDocumentMemoryBlock == null) {
       //  Error...
       continue;
     }
     try {
       PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock);
       if (peFileReader.ReaderState < ReaderState.Metadata) {
         //  Error...
         continue;
       }
       if (peFileReader.IsAssembly) {
         //  Error...
         continue;
       }
       ModuleIdentity moduleIdentity = this.GetModuleIdentifier(peFileReader, assemblyIdentity);
       PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, assembly, this.metadataReaderHost.PointerSize);
       memberModuleList.Add(peFileToObjectModel.Module);
     } catch (MetadataReaderException) {
       continue;
     }
   }
   if (memberModuleList.Count == 0)
     return;
   assembly.SetMemberModules(new EnumerableArrayWrapper<Module, IModule>(memberModuleList.ToArray(), Dummy.Module));
 }
 //^ requires peFileReader.ReaderState >= ReaderState.Metadata;
 //^ ensures (result.Location != null && result.Location.Length != 0);
 /// <summary>
 /// Computes the ModuleIdentifier of the PE File as if the module belong to given assembly.
 /// </summary>
 /// <param name="peFileReader"></param>
 /// <param name="containingAssemblyIdentity"></param>
 /// <returns></returns>
 internal ModuleIdentity GetModuleIdentifier(PEFileReader peFileReader, AssemblyIdentity containingAssemblyIdentity)
 {
     ModuleRow moduleRow = peFileReader.ModuleTable[1];
       IName moduleName = this.metadataReaderHost.NameTable.GetNameFor(peFileReader.StringStream[moduleRow.Name]);
       return new ModuleIdentity(moduleName, peFileReader.BinaryDocumentMemoryBlock.BinaryDocument.Location, containingAssemblyIdentity);
 }
예제 #9
0
 /// <summary>
 /// This method loads a module from a file containing only the metadata section of a PE file. (No headers and no IL.)
 /// </summary>
 /// <param name="binaryDocument">The binary document that needes to be opened as an module.</param>
 /// <returns>Module that is loaded or Dummy.Module in case module could not be loaded.</returns>
 public IModule OpenSnapshot(IBinaryDocument binaryDocument) {
   ModuleIdentity moduleIdentity;
   lock (GlobalLock.LockingObject) {
     IBinaryDocumentMemoryBlock/*?*/ binaryDocumentMemoryBlock = this.metadataReaderHost.OpenBinaryDocument(binaryDocument);
     if (binaryDocumentMemoryBlock == null) {
       //  Error...
       return Dummy.Module;
     }
     PEFileReader peFileReader = new PEFileReader(this, binaryDocumentMemoryBlock, snapshot: true);
     if (peFileReader.ReaderState < ReaderState.Metadata) {
       //  Error...
       return Dummy.Module;
     }
     if (peFileReader.IsAssembly) {
       AssemblyIdentity assemblyIdentity = this.GetAssemblyIdentifier(peFileReader);
       moduleIdentity = assemblyIdentity;
       Assembly/*?*/ lookupAssembly = this.LookupAssembly(null, assemblyIdentity);
       if (lookupAssembly != null) {
         return lookupAssembly;
       }
     } else {
       moduleIdentity = this.GetModuleIdentifier(peFileReader);
       Module/*?*/ lookupModule = this.LookupModule(null, moduleIdentity);
       if (lookupModule != null) {
         return lookupModule;
       }
     }
     if (peFileReader.ReaderState < ReaderState.Metadata) {
       //  Error...
       return Dummy.Module;
     }
     try {
       PEFileToObjectModel peFileToObjectModel = new PEFileToObjectModel(this, peFileReader, moduleIdentity, null, this.metadataReaderHost.PointerSize);
       this.LoadedModule(peFileToObjectModel.Module);
       CciEventSource.Log.ModuleOpened(peFileToObjectModel.Module, moduleIdentity, binaryDocument.Length);
       return peFileToObjectModel.Module;
     } catch (MetadataReaderException) {
       //  Error...
     }
   }
   return Dummy.Module;
 }
예제 #10
0
        //^ requires peFileReader.IsAssembly ==> moduleIdentity.ContainingAssembly != null;
        //^ requires peFileReader.IsAssembly ==> containingAssembly == null;
        //^ requires !(moduleIdentity.Location != null && moduleIdentity.Location.Length != 0);
        /*^
        #pragma warning disable 2666, 2669, 2677, 2674
        ^*/
        internal PEFileToObjectModel(
      PeReader peReader,
      PEFileReader peFileReader,
      ModuleIdentity moduleIdentity,
      Assembly/*?*/ containingAssembly,
      byte pointerSize
    )
        {
            this.pointerSize = pointerSize;
              this.ModuleReader = peReader;
              this.PEFileReader = peFileReader;
              this.NameTable = peReader.metadataReaderHost.NameTable;
              this.StringIndexToNameTable = new Hashtable<IName>();
              this.StringIndexToUnmangledNameTable = new Hashtable<IName>();
              this.typeCache = new TypeCache(this);
              uint moduleNameOffset = peFileReader.ModuleTable.GetName(1);
              IName moduleName = this.GetNameFromOffset(moduleNameOffset);
              AssemblyIdentity/*?*/ assemblyIdentity = moduleIdentity as AssemblyIdentity;
              if (peFileReader.IsAssembly) {
            //^ assert assemblyIdentity != null;
            AssemblyRow assemblyRow = peFileReader.AssemblyTable[1];
            IName assemblyName = this.GetNameFromOffset(assemblyRow.Name);
            byte[] publicKeyArray = TypeCache.EmptyByteArray;
            if (assemblyRow.PublicKey != 0) {
              publicKeyArray = peFileReader.BlobStream[assemblyRow.PublicKey];
            }
            uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetAssemblyInternedKey(assemblyIdentity);
            Assembly assem = new Assembly(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, assemblyIdentity, assemblyName, assemblyRow.Flags, publicKeyArray);
            this.ContainingAssembly = assem;
            this.Module = assem;
              } else {
            uint internedModuleId = (uint)peReader.metadataReaderHost.InternFactory.GetModuleInternedKey(moduleIdentity);
            this.ContainingAssembly = containingAssembly;
            this.Module = new Module(this, moduleName, peFileReader.COR20Header.COR20Flags, internedModuleId, moduleIdentity);
              }

              this.LoadAssemblyReferences();
              this.LoadModuleReferences();
              this.RootModuleNamespace = new RootNamespace(this);
              this.NamespaceINameHashtable = new Hashtable<Namespace>();
              this.LoadNamespaces();
              this.NamespaceReferenceINameHashtable = new DoubleHashtable<NamespaceReference>();
              this.NamespaceTypeTokenTable = new DoubleHashtable(peFileReader.TypeDefTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
              this.NestedTypeTokenTable = new DoubleHashtable(peFileReader.NestedClassTable.NumberOfRows + peFileReader.ExportedTypeTable.NumberOfRows);
              this.PreLoadTypeDefTableLookup();
              this.ModuleTypeDefArray = new TypeBase/*?*/[peFileReader.TypeDefTable.NumberOfRows + 1];
              this.ModuleTypeDefLoadState = new LoadState[peFileReader.TypeDefTable.NumberOfRows + 1];
              this.ModuleTypeDefLoadState[0] = LoadState.Loaded;

              this.ExportedTypeArray = new ExportedTypeAliasBase/*?*/[peFileReader.ExportedTypeTable.NumberOfRows + 1];
              this.ExportedTypeLoadState = new LoadState[peFileReader.ExportedTypeTable.NumberOfRows + 1];
              this.ExportedTypeLoadState[0] = LoadState.Loaded;

              this.ModuleGenericParamArray = new GenericParameter[peFileReader.GenericParamTable.NumberOfRows + 1];
              if (peFileReader.MethodSpecTable.NumberOfRows > 0) {
            this.ModuleMethodSpecHashtable = new DoubleHashtable<GenericMethodInstanceReference>(peFileReader.MethodSpecTable.NumberOfRows + 1);
              }

              this.ModuleTypeRefReferenceArray = new TypeRefReference[peFileReader.TypeRefTable.NumberOfRows + 1];
              this.ModuleTypeRefReferenceLoadState = new LoadState[peFileReader.TypeRefTable.NumberOfRows + 1];
              this.ModuleTypeRefReferenceLoadState[0] = LoadState.Loaded;
              if (peFileReader.TypeSpecTable.NumberOfRows > 0) {
            this.ModuleTypeSpecHashtable = new DoubleHashtable<TypeSpecReference>(peFileReader.TypeSpecTable.NumberOfRows + 1);
              }

              this.ModuleFieldArray = new FieldDefinition[peFileReader.FieldTable.NumberOfRows + 1];
              this.ModuleMethodArray = new MethodDefinition[peFileReader.MethodTable.NumberOfRows + 1];
              this.ModuleEventArray = new EventDefinition[peFileReader.EventTable.NumberOfRows + 1];
              this.ModulePropertyArray = new PropertyDefinition[peFileReader.PropertyTable.NumberOfRows + 1];

              this.ModuleMemberReferenceArray = new MemberReference/*?*/[peFileReader.MemberRefTable.NumberOfRows + 1];

              this.CustomAttributeArray = new ICustomAttribute/*?*/[peFileReader.CustomAttributeTable.NumberOfRows + 1];

              this.DeclSecurityArray = new ISecurityAttribute/*?*/[peFileReader.DeclSecurityTable.NumberOfRows + 1];

              uint moduleClassTypeDefToken = this.NamespaceTypeTokenTable.Find((uint)this.NameTable.EmptyName.UniqueKey, (uint)peReader._Module_.UniqueKey);
              _Module_Type/*?*/ _module_ = null;
              if (moduleClassTypeDefToken != 0 && ((TokenTypeIds.TokenTypeMask & moduleClassTypeDefToken) == TokenTypeIds.TypeDef)) {
            _module_ = this.Create_Module_Type(moduleClassTypeDefToken & TokenTypeIds.RIDMask);
              }
              if (_module_ == null) {
            //  Error
            throw new MetadataReaderException("<Module> Type not present");
              }
              this._Module_ = _module_;
              //^ NonNullType.AssertInitialized(this.ModuleGenericParamArray);
              //^ NonNullType.AssertInitialized(this.ModuleTypeRefReferenceArray);
              //^ NonNullType.AssertInitialized(this.ModuleFieldArray);
              //^ NonNullType.AssertInitialized(this.ModuleMethodArray);
              //^ NonNullType.AssertInitialized(this.ModuleEventArray);
              //^ NonNullType.AssertInitialized(this.ModulePropertyArray);
        }