diff options
Diffstat (limited to 'tools/Sandcastle/Source/CCI/Writer.cs')
| -rw-r--r-- | tools/Sandcastle/Source/CCI/Writer.cs | 6397 |
1 files changed, 6397 insertions, 0 deletions
diff --git a/tools/Sandcastle/Source/CCI/Writer.cs b/tools/Sandcastle/Source/CCI/Writer.cs new file mode 100644 index 0000000..28a3668 --- /dev/null +++ b/tools/Sandcastle/Source/CCI/Writer.cs @@ -0,0 +1,6397 @@ +// Copyright © Microsoft Corporation. +// This source file is subject to the Microsoft Permissive License. +// See http://www.microsoft.com/resources/sharedsource/licensingbasics/sharedsourcelicenses.mspx. +// All other rights reserved. + +#if !NoWriter +using System; +using System.Collections; +#if CCINamespace +using Microsoft.Cci.Metadata; +#else +using System.Compiler.Metadata; +#endif +using System.Diagnostics; +using System.IO; +using System.Globalization; +using System.Runtime.InteropServices; +using System.Security; +#if !ROTOR +using System.Security.Cryptography; +#endif +using System.Text; + +#if CCINamespace +namespace Microsoft.Cci{ +#else +namespace System.Compiler +{ +#endif +#if !ROTOR + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("B01FAFEB-C450-3A4D-BEEC-B4CEEC01E006"), SuppressUnmanagedCodeSecurity] + interface ISymUnmanagedDocumentWriter + { + void SetSource(uint sourceSize, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 0)] byte[] source); + void SetCheckSum(ref Guid algorithmId, uint checkSumSize, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] checkSum); + }; + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("2DE91396-3844-3B1D-8E91-41C24FD672EA"), SuppressUnmanagedCodeSecurity] + interface ISymUnmanagedWriter + { + ISymUnmanagedDocumentWriter DefineDocument(string url, ref Guid language, ref Guid languageVendor, ref Guid documentType); + void SetUserEntryPoint(uint entryMethod); + void OpenMethod(uint method); + void CloseMethod(); + uint OpenScope(uint startOffset); + void CloseScope(uint endOffset); + void SetScopeRange(uint scopeID, uint startOffset, uint endOffset); + void DefineLocalVariable(string name, uint attributes, uint cSig, IntPtr signature, uint addrKind, uint addr1, uint addr2, uint startOffset, uint endOffset); + void DefineParameter(string name, uint attributes, uint sequence, uint addrKind, uint addr1, uint addr2, uint addr3); + void DefineField(uint parent, string name, uint attributes, uint cSig, IntPtr signature, uint addrKind, uint addr1, uint addr2, uint addr3); + void DefineGlobalVariable(string name, uint attributes, uint cSig, IntPtr signature, uint addrKind, uint addr1, uint addr2, uint addr3); + void Close(); + void SetSymAttribute(uint parent, string name, uint cData, IntPtr signature); + void OpenNamespace(string name); + void CloseNamespace(); + void UsingNamespace(string fullName); + void SetMethodSourceRange(ISymUnmanagedDocumentWriter startDoc, uint startLine, uint startColumn, object endDoc, uint endLine, uint endColumn); + void Initialize([MarshalAs(UnmanagedType.IUnknown)]object emitter, string filename, [MarshalAs(UnmanagedType.IUnknown)]object pIStream, bool fFullBuild); + void GetDebugInfo(ref ImageDebugDirectory pIDD, uint cData, out uint pcData, IntPtr data); + void DefineSequencePoints(ISymUnmanagedDocumentWriter document, uint spCount, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] offsets, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] lines, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] columns, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] endLines, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] uint[] endColumns); + void RemapToken(uint oldToken, uint newToken); + void Initialize2([MarshalAs(UnmanagedType.IUnknown)]object emitter, string tempfilename, [MarshalAs(UnmanagedType.IUnknown)]object pIStream, bool fFullBuild, string finalfilename); + void DefineConstant(string name, object value, uint cSig, IntPtr signature); + } + struct ImageDebugDirectory + { + internal int Characteristics; + internal int TimeDateStamp; + internal short MajorVersion; + internal short MinorVersion; + internal int Type; + internal int SizeOfData; + internal int AddressOfRawData; + internal int PointerToRawData; + public ImageDebugDirectory(bool zeroFill) + { + this.Characteristics = 0; + this.TimeDateStamp = 0; + this.MajorVersion = 0; + this.MinorVersion = 0; + this.Type = 0; + this.SizeOfData = 0; + this.AddressOfRawData = 0; + this.PointerToRawData = 0; + } + } + + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("BA3FEE4C-ECB9-4e41-83B7-183FA41CD859")] + unsafe public interface IMetaDataEmit + { + void SetModuleProps(string szName); + void Save(string szFile, uint dwSaveFlags); + void SaveToStream(void* pIStream, uint dwSaveFlags); + uint GetSaveSize(uint fSave); + uint DefineTypeDef(char* szTypeDef, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements); + uint DefineNestedType(char* szTypeDef, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements, uint tdEncloser); + void SetHandler([MarshalAs(UnmanagedType.IUnknown), In]object pUnk); + uint DefineMethod(uint td, char* zName, uint dwMethodFlags, byte* pvSigBlob, uint cbSigBlob, uint ulCodeRVA, uint dwImplFlags); + void DefineMethodImpl(uint td, uint tkBody, uint tkDecl); + uint DefineTypeRefByName(uint tkResolutionScope, char* szName); + uint DefineImportType(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, IMetaDataImport pImport, + uint tdImport, IntPtr pAssemEmit); + uint DefineMemberRef(uint tkImport, string szName, byte* pvSigBlob, uint cbSigBlob); + uint DefineImportMember(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, + IMetaDataImport pImport, uint mbMember, IntPtr pAssemEmit, uint tkParent); + uint DefineEvent(uint td, string szEvent, uint dwEventFlags, uint tkEventType, uint mdAddOn, uint mdRemoveOn, uint mdFire, uint* rmdOtherMethods); + void SetClassLayout(uint td, uint dwPackSize, COR_FIELD_OFFSET* rFieldOffsets, uint ulClassSize); + void DeleteClassLayout(uint td); + void SetFieldMarshal(uint tk, byte* pvNativeType, uint cbNativeType); + void DeleteFieldMarshal(uint tk); + uint DefinePermissionSet(uint tk, uint dwAction, void* pvPermission, uint cbPermission); + void SetRVA(uint md, uint ulRVA); + uint GetTokenFromSig(byte* pvSig, uint cbSig); + uint DefineModuleRef(string szName); + void SetParent(uint mr, uint tk); + uint GetTokenFromTypeSpec(byte* pvSig, uint cbSig); + void SaveToMemory(void* pbData, uint cbData); + uint DefineUserString(string szString, uint cchString); + void DeleteToken(uint tkObj); + void SetMethodProps(uint md, uint dwMethodFlags, uint ulCodeRVA, uint dwImplFlags); + void SetTypeDefProps(uint td, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements); + void SetEventProps(uint ev, uint dwEventFlags, uint tkEventType, uint mdAddOn, uint mdRemoveOn, uint mdFire, uint* rmdOtherMethods); + uint SetPermissionSetProps(uint tk, uint dwAction, void* pvPermission, uint cbPermission); + void DefinePinvokeMap(uint tk, uint dwMappingFlags, string szImportName, uint mrImportDLL); + void SetPinvokeMap(uint tk, uint dwMappingFlags, string szImportName, uint mrImportDLL); + void DeletePinvokeMap(uint tk); + uint DefineCustomAttribute(uint tkObj, uint tkType, void* pCustomAttribute, uint cbCustomAttribute); + void SetCustomAttributeValue(uint pcv, void* pCustomAttribute, uint cbCustomAttribute); + uint DefineField(uint td, string szName, uint dwFieldFlags, byte* pvSigBlob, uint cbSigBlob, uint dwCPlusTypeFlag, void* pValue, uint cchValue); + uint DefineProperty(uint td, string szProperty, uint dwPropFlags, byte* pvSig, uint cbSig, uint dwCPlusTypeFlag, + void* pValue, uint cchValue, uint mdSetter, uint mdGetter, uint* rmdOtherMethods); + uint DefineParam(uint md, uint ulParamSeq, string szName, uint dwParamFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue); + void SetFieldProps(uint fd, uint dwFieldFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue); + void SetPropertyProps(uint pr, uint dwPropFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue, uint mdSetter, uint mdGetter, uint* rmdOtherMethods); + void SetParamProps(uint pd, string szName, uint dwParamFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue); + uint DefineSecurityAttributeSet(uint tkObj, IntPtr rSecAttrs, uint cSecAttrs); + void ApplyEditAndContinue([MarshalAs(UnmanagedType.IUnknown)]object pImport); + uint TranslateSigWithScope(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, + IMetaDataImport import, byte* pbSigBlob, uint cbSigBlob, IntPtr pAssemEmit, IMetaDataEmit emit, byte* pvTranslatedSig, uint cbTranslatedSigMax); + void SetMethodImplFlags(uint md, uint dwImplFlags); + void SetFieldRVA(uint fd, uint ulRVA); + void Merge(IMetaDataImport pImport, IntPtr pHostMapToken, [MarshalAs(UnmanagedType.IUnknown)]object pHandler); + void MergeEnd(); + } + public struct COR_FIELD_OFFSET + { + public uint ridOfField; + public uint ulOffset; + } + [ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("7DAC8207-D3AE-4c75-9B67-92801A497D44")] + unsafe public interface IMetaDataImport + { + [PreserveSig] + void CloseEnum(uint hEnum); + uint CountEnum(uint hEnum); + void ResetEnum(uint hEnum, uint ulPos); + uint EnumTypeDefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeDefs, uint cMax); + uint EnumInterfaceImpls(ref uint phEnum, uint td, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rImpls, uint cMax); + uint EnumTypeRefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeRefs, uint cMax); + uint FindTypeDefByName(string szTypeDef, uint tkEnclosingClass); + Guid GetScopeProps(StringBuilder szName, uint cchName, out uint pchName); + uint GetModuleFromScope(); + uint GetTypeDefProps(uint td, IntPtr szTypeDef, uint cchTypeDef, out uint pchTypeDef, IntPtr pdwTypeDefFlags); + uint GetInterfaceImplProps(uint iiImpl, out uint pClass); + uint GetTypeRefProps(uint tr, out uint ptkResolutionScope, StringBuilder szName, uint cchName); + uint ResolveTypeRef(uint tr, [In] ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppIScope); + uint EnumMembers(ref uint phEnum, uint cl, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rMembers, uint cMax); + uint EnumMembersWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMembers, uint cMax); + uint EnumMethods(ref uint phEnum, uint cl, uint* rMethods, uint cMax); + uint EnumMethodsWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethods, uint cMax); + uint EnumFields(ref uint phEnum, uint cl, uint* rFields, uint cMax); + uint EnumFieldsWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rFields, uint cMax); + uint EnumParams(ref uint phEnum, uint mb, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rParams, uint cMax); + uint EnumMemberRefs(ref uint phEnum, uint tkParent, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rMemberRefs, uint cMax); + uint EnumMethodImpls(ref uint phEnum, uint td, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethodBody, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethodDecl, uint cMax); + uint EnumPermissionSets(ref uint phEnum, uint tk, uint dwActions, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rPermission, + uint cMax); + uint FindMember(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob); + uint FindMethod(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob); + uint FindField(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob); + uint FindMemberRef(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob); + uint GetMethodProps(uint mb, out uint pClass, IntPtr szMethod, uint cchMethod, out uint pchMethod, IntPtr pdwAttr, + IntPtr ppvSigBlob, IntPtr pcbSigBlob, IntPtr pulCodeRVA); + unsafe uint GetMemberRefProps(uint mr, ref uint ptk, StringBuilder szMember, uint cchMember, out uint pchMember, out byte* ppvSigBlob); + uint EnumProperties(ref uint phEnum, uint td, uint* rProperties, uint cMax); + uint EnumEvents(ref uint phEnum, uint td, uint* rEvents, uint cMax); + uint GetEventProps(uint ev, out uint pClass, StringBuilder szEvent, uint cchEvent, out uint pchEvent, out uint pdwEventFlags, + out uint ptkEventType, out uint pmdAddOn, out uint pmdRemoveOn, out uint pmdFire, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 11)] uint[] rmdOtherMethod, uint cMax); + uint EnumMethodSemantics(ref uint phEnum, uint mb, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rEventProp, uint cMax); + uint GetMethodSemantics(uint mb, uint tkEventProp); + uint GetClassLayout(uint td, out uint pdwPackSize, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] COR_FIELD_OFFSET[] rFieldOffset, uint cMax, out uint pcFieldOffset); + unsafe uint GetFieldMarshal(uint tk, out byte* ppvNativeType); + uint GetRVA(uint tk, out uint pulCodeRVA); + unsafe uint GetPermissionSetProps(uint pm, out uint pdwAction, out void* ppvPermission); + unsafe uint GetSigFromToken(uint mdSig, out byte* ppvSig); + uint GetModuleRefProps(uint mur, StringBuilder szName, uint cchName); + uint EnumModuleRefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rModuleRefs, uint cmax); + unsafe uint GetTypeSpecFromToken(uint typespec, out byte* ppvSig); + uint GetNameFromToken(uint tk); + uint EnumUnresolvedMethods(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rMethods, uint cMax); + uint GetUserString(uint stk, StringBuilder szString, uint cchString); + uint GetPinvokeMap(uint tk, out uint pdwMappingFlags, StringBuilder szImportName, uint cchImportName, out uint pchImportName); + uint EnumSignatures(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rSignatures, uint cmax); + uint EnumTypeSpecs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeSpecs, uint cmax); + uint EnumUserStrings(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rStrings, uint cmax); + [PreserveSig] + int GetParamForMethodIndex(uint md, uint ulParamSeq, out uint pParam); + uint EnumCustomAttributes(ref uint phEnum, uint tk, uint tkType, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rCustomAttributes, uint cMax); + uint GetCustomAttributeProps(uint cv, out uint ptkObj, out uint ptkType, out void* ppBlob); + uint FindTypeRef(uint tkResolutionScope, string szName); + uint GetMemberProps(uint mb, out uint pClass, StringBuilder szMember, uint cchMember, out uint pchMember, out uint pdwAttr, + out byte* ppvSigBlob, out uint pcbSigBlob, out uint pulCodeRVA, out uint pdwImplFlags, out uint pdwCPlusTypeFlag, out void* ppValue); + uint GetFieldProps(uint mb, out uint pClass, StringBuilder szField, uint cchField, out uint pchField, out uint pdwAttr, + out byte* ppvSigBlob, out uint pcbSigBlob, out uint pdwCPlusTypeFlag, out void* ppValue); + uint GetPropertyProps(uint prop, out uint pClass, StringBuilder szProperty, uint cchProperty, out uint pchProperty, out uint pdwPropFlags, + out byte* ppvSig, out uint pbSig, out uint pdwCPlusTypeFlag, out void* ppDefaultValue, out uint pcchDefaultValue, out uint pmdSetter, + out uint pmdGetter, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 14)] uint[] rmdOtherMethod, uint cMax); + uint GetParamProps(uint tk, out uint pmd, out uint pulSequence, StringBuilder szName, uint cchName, out uint pchName, + out uint pdwAttr, out uint pdwCPlusTypeFlag, out void* ppValue); + uint GetCustomAttributeByName(uint tkObj, string szName, out void* ppData); + [PreserveSig] + [return: MarshalAs(UnmanagedType.Bool)] + bool IsValidToken(uint tk); + uint GetNestedClassProps(uint tdNestedClass); + uint GetNativeCallConvFromSig(void* pvSig, uint cbSig); + int IsGlobal(uint pd); + } + [SuppressUnmanagedCodeSecurity] + internal sealed class Ir2md : IMetaDataEmit, IMetaDataImport + { +#else + internal sealed class Ir2md{ +#endif + private AssemblyNode assembly; + private Module/*!*/ module; + private MetadataWriter/*!*/ writer; + private bool UseGenerics = false; + private bool StripOptionalModifiersFromLocals + { + get { return this.module.StripOptionalModifiersFromLocals; } + } + private BinaryWriter/*!*/ blobHeap = new BinaryWriter(new MemoryStream(), System.Text.Encoding.Unicode); +#if WHIDBEYwithGenerics || WHIDBEYwithGenericsAndIEqualityComparer + private Hashtable/*!*/ blobHeapIndex = new Hashtable(new ByteArrayKeyComparer()); +#else + private Hashtable/*!*/ blobHeapIndex = new Hashtable(new ByteArrayHasher(), new ByteArrayComparer()); +#endif + private Hashtable/*!*/ blobHeapStringIndex = new Hashtable(); + private NodeList/*!*/ nodesWithCustomAttributes = new NodeList(); + private int customAttributeCount = 0; + private NodeList/*!*/ nodesWithSecurityAttributes = new NodeList(); + private int securityAttributeCount = 0; + private NodeList/*!*/ constantTableEntries = new NodeList(); + private TrivialHashtable/*!*/ assemblyRefIndex = new TrivialHashtable(); + private AssemblyReferenceList/*!*/ assemblyRefEntries = new AssemblyReferenceList(); + private TypeNodeList/*!*/ classLayoutEntries = new TypeNodeList(); + private TrivialHashtable/*!*/ documentMap = new TrivialHashtable(); + private TrivialHashtable/*!*/ eventIndex = new TrivialHashtable(); + private EventList/*!*/ eventEntries = new EventList(); + private TrivialHashtable/*!*/ eventMapIndex = new TrivialHashtable(); + private EventList/*!*/ eventMapEntries = new EventList(); + private TrivialHashtable/*!*/ exceptionBlock = new TrivialHashtable(); + private TrivialHashtable/*!*/ fieldIndex = new TrivialHashtable(); + private FieldList/*!*/ fieldEntries = new FieldList(); + private FieldList/*!*/ fieldLayoutEntries = new FieldList(); + private FieldList/*!*/ fieldRvaEntries = new FieldList(); + private Hashtable/*!*/ fileTableIndex = new Hashtable(); + private ModuleList/*!*/ fileTableEntries = new ModuleList(); + private Hashtable/*!*/ genericParamIndex = new Hashtable(); + private MemberList/*!*/ genericParamEntries = new MemberList(); + private TypeNodeList/*!*/ genericParameters = new TypeNodeList(); + private TypeNodeList/*!*/ genericParamConstraintEntries = new TypeNodeList(); + private ArrayList/*!*/ guidEntries = new ArrayList(); + private Hashtable/*!*/ guidIndex = new Hashtable(); + private MethodList/*!*/ implMapEntries = new MethodList(); + private TypeNodeList/*!*/ interfaceEntries = new TypeNodeList(); + private NodeList/*!*/ marshalEntries = new NodeList(); + private TrivialHashtable/*!*/ memberRefIndex = new TrivialHashtable(); + private MemberList/*!*/ memberRefEntries = new MemberList(); + private TrivialHashtable/*!*/ methodBodiesHeapIndex = new TrivialHashtable(); + private BinaryWriter/*!*/ methodBodiesHeap = new BinaryWriter(new MemoryStream()); + private BinaryWriter/*!*/ methodBodyHeap; + private MethodList/*!*/ methodEntries = new MethodList(); + private TrivialHashtable/*!*/ methodIndex = new TrivialHashtable(); + private MethodList/*!*/ methodImplEntries = new MethodList(); + private MethodInfo/*!*/ methodInfo; + private Method currentMethod; + private MemberList/*!*/ methodSemanticsEntries = new MemberList(); + private MethodList/*!*/ methodSpecEntries = new MethodList(); + private Hashtable/*!*/ methodSpecIndex = new Hashtable(); + private ModuleReferenceList/*!*/ moduleRefEntries = new ModuleReferenceList(); + private Hashtable/*!*/ moduleRefIndex = new Hashtable(); + private TypeNodeList/*!*/ nestedClassEntries = new TypeNodeList(); + private TrivialHashtable/*!*/ paramIndex = new TrivialHashtable(); + private ParameterList/*!*/ paramEntries = new ParameterList(); + private TrivialHashtable/*!*/ propertyIndex = new TrivialHashtable(); + private PropertyList/*!*/ propertyEntries = new PropertyList(); + private TrivialHashtable/*!*/ propertyMapIndex = new TrivialHashtable(); + private PropertyList/*!*/ propertyMapEntries = new PropertyList(); + private BinaryWriter/*!*/ resourceDataHeap = new BinaryWriter(new MemoryStream()); + private BinaryWriter/*!*/ sdataHeap = new BinaryWriter(new MemoryStream()); +#if !ROTOR + private ISymUnmanagedWriter symWriter = null; +#endif + private int stackHeight; + private int stackHeightMax; + private int stackHeightExitTotal; + private ArrayList/*!*/ standAloneSignatureEntries = new ArrayList(); + private BinaryWriter/*!*/ stringHeap = new BinaryWriter(new MemoryStream()); + private Hashtable/*!*/ stringHeapIndex = new Hashtable(); + private BinaryWriter/*!*/ tlsHeap = new BinaryWriter(new MemoryStream()); + private TrivialHashtable/*!*/ typeDefIndex = new TrivialHashtable(); + private TypeNodeList/*!*/ typeDefEntries = new TypeNodeList(); + private TrivialHashtable/*!*/ typeRefIndex = new TrivialHashtable(); + private TypeNodeList/*!*/ typeRefEntries = new TypeNodeList(); + private TrivialHashtable/*!*/ typeSpecIndex = new TrivialHashtable(); + private TypeNodeList/*!*/ typeSpecEntries = new TypeNodeList(); + private TrivialHashtable/*!*/ typeParameterNumber = new TrivialHashtable(); + private BinaryWriter/*!*/ userStringHeap = new BinaryWriter(new MemoryStream(), System.Text.Encoding.Unicode); + private Hashtable/*!*/ userStringHeapIndex = new Hashtable(); + private byte[] PublicKey; + + internal Ir2md(Module/*!*/ module) + { + this.assembly = module as AssemblyNode; + this.module = module; + //^ base(); + this.blobHeap.Write((byte)0); + this.stringHeap.Write((byte)0); + this.userStringHeap.Write((byte)0); + if (this.assembly != null) + this.PublicKey = this.assembly.PublicKeyOrToken; + } + internal static void WritePE(Module/*!*/ module, string debugSymbolsLocation, BinaryWriter/*!*/ writer) + { + Ir2md ir2md = new Ir2md(module); + try + { + ir2md.SetupMetadataWriter(debugSymbolsLocation); + MetadataWriter mdWriter = ir2md.writer; + mdWriter.WritePE(writer); + } + finally + { +#if !ROTOR + if (ir2md.symWriter != null) + ir2md.symWriter.Close(); +#endif + ir2md.assembly = null; + ir2md.assemblyRefEntries = null; + ir2md.assemblyRefIndex = null; + ir2md.blobHeap = null; + ir2md.blobHeapIndex = null; + ir2md.blobHeapStringIndex = null; + ir2md.classLayoutEntries = null; + ir2md.constantTableEntries = null; + ir2md.documentMap = null; + ir2md.eventEntries = null; + ir2md.eventIndex = null; + ir2md.eventMapEntries = null; + ir2md.eventMapIndex = null; + ir2md.exceptionBlock = null; + ir2md.fieldEntries = null; + ir2md.fieldIndex = null; + ir2md.fieldLayoutEntries = null; + ir2md.fieldRvaEntries = null; + ir2md.fileTableEntries = null; + ir2md.fileTableIndex = null; + ir2md.genericParamConstraintEntries = null; + ir2md.genericParamEntries = null; + ir2md.genericParameters = null; + ir2md.genericParamIndex = null; + ir2md.guidEntries = null; + ir2md.guidIndex = null; + ir2md.implMapEntries = null; + ir2md.interfaceEntries = null; + ir2md.marshalEntries = null; + ir2md.memberRefEntries = null; + ir2md.memberRefIndex = null; + ir2md.methodBodiesHeap = null; + ir2md.methodBodiesHeapIndex = null; + ir2md.methodBodyHeap = null; + ir2md.methodEntries = null; + ir2md.methodImplEntries = null; + ir2md.methodIndex = null; + ir2md.methodInfo = null; + ir2md.currentMethod = null; + ir2md.methodSemanticsEntries = null; + ir2md.methodSpecEntries = null; + ir2md.methodSpecIndex = null; + ir2md.module = null; + ir2md.moduleRefEntries = null; + ir2md.moduleRefIndex = null; + ir2md.nestedClassEntries = null; + ir2md.nodesWithCustomAttributes = null; + ir2md.nodesWithSecurityAttributes = null; + ir2md.paramEntries = null; + ir2md.paramIndex = null; + ir2md.propertyEntries = null; + ir2md.propertyIndex = null; + ir2md.propertyMapEntries = null; + ir2md.propertyMapIndex = null; + ir2md.PublicKey = null; + ir2md.resourceDataHeap = null; + ir2md.sdataHeap = null; + ir2md.standAloneSignatureEntries = null; + ir2md.stringHeap = null; + ir2md.stringHeapIndex = null; +#if !ROTOR + ir2md.symWriter = null; +#endif + ir2md.tlsHeap = null; + ir2md.typeDefEntries = null; + ir2md.typeDefIndex = null; + ir2md.typeParameterNumber = null; + ir2md.typeRefEntries = null; + ir2md.typeRefIndex = null; + ir2md.typeSpecEntries = null; + ir2md.typeSpecIndex = null; + ir2md.unspecializedFieldFor = null; + ir2md.unspecializedMethodFor = null; + ir2md.userStringHeap = null; + ir2md.userStringHeapIndex = null; + ir2md.writer = null; + ir2md = null; + } + } + + private static Guid IID_IUnknown = new Guid("00000000-0000-0000-C000-000000000046"); + private static Guid IID_IClassFactory = new Guid("00000001-0000-0000-C000-000000000046"); + + [ComImport(), Guid("00000001-0000-0000-C000-000000000046"), InterfaceTypeAttribute(ComInterfaceType.InterfaceIsIUnknown)] + interface IClassFactory + { + int CreateInstance( + [In, MarshalAs(UnmanagedType.Interface)] object unused, + [In] ref Guid refiid, + [MarshalAs(UnmanagedType.Interface)] out Object ppunk); + int LockServer( + int fLock); + } + + delegate int GetClassObjectDelegate([In] ref Guid refclsid, + [In] ref Guid refiid, + [MarshalAs(UnmanagedType.Interface)] out IClassFactory ppUnk); + + [DllImport("kernel32.dll", CharSet = CharSet.Ansi)] + private static extern int LoadLibrary(string lpFileName); + [DllImport("kernel32.dll", CharSet = CharSet.Ansi)] + private static extern GetClassObjectDelegate GetProcAddress(int hModule, string lpProcName); + + private object CrossCompileActivate(string server, Guid guid) + { + // Poor man's version of Activator.CreateInstance or CoCreate + object o = null; + int hmod = LoadLibrary(server); + if (hmod != 0) + { + GetClassObjectDelegate del = GetProcAddress(hmod, "DllGetClassObject"); + if (del != null) + { + IClassFactory icf; + int hr = del(ref guid, ref IID_IClassFactory, out icf); + if (hr == 0 && icf != null) + { + object temp = null; + hr = icf.CreateInstance(null, ref IID_IUnknown, out temp); + if (hr == 0) o = temp; + } + } + } + return o; + } + private void SetupMetadataWriter(string debugSymbolsLocation) + { + Version v = TargetPlatform.TargetVersion; + this.UseGenerics = TargetPlatform.UseGenerics; +#if !ROTOR + if (debugSymbolsLocation != null) + { + // If targeting RTM (Version.Major = 1 and Version.Minor = 0) + // then use Symwriter.pdb as ProgID else use CorSymWriter_SxS + // (Note that RTM version 1.0.3705 has Assembly version 1.0.3300, + // hence the <= 3705 expression. This also leaves room for RTM SP releases + // with slightly different build numbers). + Type t = null; + if (v.Major == 1 && v.Minor == 0 && v.Build <= 3705) + { + try + { + t = Type.GetTypeFromProgID("Symwriter.pdb", false); + this.symWriter = (ISymUnmanagedWriter)Activator.CreateInstance(t); + if (this.symWriter != null) + this.symWriter.Initialize(this, debugSymbolsLocation, null, true); + } + catch (Exception) + { + t = null; + this.symWriter = null; + } + } + if (t == null) + { + Debug.Assert(this.symWriter == null); + t = Type.GetTypeFromProgID("CorSymWriter_SxS", false); + if (t != null) + { + Guid guid = t.GUID; + + // If the compiler was built with Whidbey, then mscoree will pick a matching + // diasymreader.dll out of the Whidbey directory. But if we are cross- + // compiling, this is *NOT* what we want. Instead, we want to override + // the shim's logic and explicitly pick a diasymreader.dll from the place + // that matches the version of the output file we are emitting. This is + // strictly illegal by the CLR's rules. However, the CLR does not yet + // support cross-compilation, so we have little choice. + if (!UseGenerics) + { + Version vcompiler = typeof(object).Assembly.GetName().Version; + if (vcompiler.Major >= 2) + { + // This is the only cross-compilation case we currently support. + string server = Path.Combine(Path.GetDirectoryName(typeof(object).Assembly.Location), + "..\\v1.1.4322\\diasymreader.dll"); + object o = CrossCompileActivate(server, guid); + this.symWriter = (ISymUnmanagedWriter)o; + } + } + if (this.symWriter == null) + { + this.symWriter = (ISymUnmanagedWriter)Activator.CreateInstance(t); + } + if (this.symWriter != null) + this.symWriter.Initialize(this, debugSymbolsLocation, null, true); + } + else + { + throw new DebugSymbolsCouldNotBeWrittenException(); + } + } + } +#endif + //Visit the module, building lists etc. + this.VisitModule(this.module); + //Use the lists to populate the tables in the metadata writer +#if !ROTOR + MetadataWriter writer = this.writer = new MetadataWriter(this.symWriter); +#else + MetadataWriter writer = this.writer = new MetadataWriter(); +#endif + writer.UseGenerics = this.UseGenerics; + if (module.EntryPoint != null) + { + writer.entryPointToken = this.GetMethodToken(module.EntryPoint); +#if !ROTOR + if (this.symWriter != null) this.symWriter.SetUserEntryPoint((uint)writer.entryPointToken); +#endif + } + writer.moduleKind = module.Kind; + writer.peKind = module.PEKind; + writer.TrackDebugData = module.TrackDebugData; + writer.fileAlignment = module.FileAlignment; + if (writer.fileAlignment < 512) writer.fileAlignment = 512; + writer.PublicKey = this.PublicKey; + if (this.assembly != null) this.PopulateAssemblyTable(); + this.PopulateClassLayoutTable(); + this.PopulateConstantTable(); + this.PopulateGenericParamTable(); //Needs to happen before PopulateCustomAttributeTable since it the latter refers to indices in the sorted table + this.PopulateCustomAttributeTable(); + this.PopulateDeclSecurityTable(); + this.PopulateEventMapTable(); + this.PopulateEventTable(); + this.PopulateExportedTypeTable(); + this.PopulateFieldTable(); + this.PopulateFieldLayoutTable(); + this.PopulateFieldRVATable(); + this.PopulateManifestResourceTable(); //This needs to happen before PopulateFileTable because resources are not visited separately + this.PopulateFileTable(); + this.PopulateGenericParamConstraintTable(); + this.PopulateImplMapTable(); + this.PopulateInterfaceImplTable(); + this.PopulateMarshalTable(); + this.PopulateMethodTable(); + this.PopulateMethodImplTable(); + this.PopulateMemberRefTable(); + this.PopulateMethodSemanticsTable(); + this.PopulateMethodSpecTable(); + this.PopulateModuleTable(); + this.PopulateModuleRefTable(); + this.PopulateNestedClassTable(); + this.PopulateParamTable(); + this.PopulatePropertyTable(); + this.PopulatePropertyMapTable(); + this.PopulateStandAloneSigTable(); + this.PopulateTypeDefTable(); + this.PopulateTypeRefTable(); + this.PopulateTypeSpecTable(); + this.PopulateGuidTable(); + this.PopulateAssemblyRefTable(); + this.writer.BlobHeap = (MemoryStream)this.blobHeap.BaseStream; //this.blobHeap = null; + this.writer.SdataHeap = (MemoryStream)this.sdataHeap.BaseStream; //this.sdataHeap = null; + this.writer.TlsHeap = (MemoryStream)this.tlsHeap.BaseStream; //this.tlsHeap = null; + this.writer.StringHeap = (MemoryStream)this.stringHeap.BaseStream; //this.stringHeap = null; + this.writer.UserstringHeap = (MemoryStream)this.userStringHeap.BaseStream; //this.userStringHeap = null; + this.writer.MethodBodiesHeap = (MemoryStream)this.methodBodiesHeap.BaseStream; //this.methodBodiesHeap = null; + this.writer.ResourceDataHeap = (MemoryStream)this.resourceDataHeap.BaseStream; //this.resourceDataHeap = null; + this.writer.Win32Resources = this.module.Win32Resources; + } + int GetAssemblyRefIndex(AssemblyNode/*!*/ assembly) + { + if (assembly.Location == "unknown:location") + throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, + ExceptionStrings.UnresolvedAssemblyReferenceNotAllowed, assembly.Name)); + Object index = this.assemblyRefIndex[assembly.UniqueKey]; + if (index == null) + { + index = this.assemblyRefEntries.Count + 1; + AssemblyReference aref = new AssemblyReference(assembly); + if (this.module.UsePublicKeyTokensForAssemblyReferences) + { + aref.PublicKeyOrToken = aref.PublicKeyToken; + aref.HashValue = null; + aref.Flags = aref.Flags & ~AssemblyFlags.PublicKey; + } + this.assemblyRefEntries.Add(aref); + this.assemblyRefIndex[assembly.UniqueKey] = index; + } + return (int)index; + } + int GetBlobIndex(ExpressionList expressions, ParameterList parameters) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + this.WriteCustomAttributeSignature(expressions, parameters, false, signature); + byte[] sigBytes = sig.ToArray(); + int length = sigBytes.Length; + int index = (int)this.blobHeap.BaseStream.Position; + Ir2md.WriteCompressedInt(this.blobHeap, length); + this.blobHeap.BaseStream.Write(sigBytes, 0, length); + return index; + } + void WriteCustomAttributeSignature(ExpressionList expressions, ParameterList parameters, bool onlyWriteNamedArguments, BinaryWriter signature) + { + int n = parameters == null ? 0 : parameters.Count; + int m = expressions == null ? 0 : expressions.Count; + Debug.Assert(m >= n); + int numNamed = m > n ? m - n : 0; + if (onlyWriteNamedArguments) + { + Ir2md.WriteCompressedInt(signature, numNamed); + } + else + { + signature.Write((short)1); + if (parameters != null && expressions != null) + { + for (int i = 0; i < n; i++) + { + Parameter p = parameters[i]; + Expression e = expressions[i]; + if (p == null || e == null) continue; + Literal l = e as Literal; + if (l == null) { Debug.Assert(false); continue; } + this.WriteCustomAttributeLiteral(signature, l, p.Type == CoreSystemTypes.Object); + } + } + signature.Write((short)numNamed); + } + if (expressions != null) + { + for (int i = n; i < m; i++) + { + Expression e = expressions[i]; + NamedArgument narg = e as NamedArgument; + if (narg == null) { Debug.Assert(false); continue; } + signature.Write((byte)(narg.IsCustomAttributeProperty ? 0x54 : 0x53)); + if (narg.ValueIsBoxed) + signature.Write((byte)ElementType.BoxedEnum); + else if (narg.Value.Type is EnumNode) + { + signature.Write((byte)ElementType.Enum); + this.WriteSerializedTypeName(signature, narg.Value.Type); + } + else if (narg.Value.Type == CoreSystemTypes.Type) + signature.Write((byte)ElementType.Type); + else if (narg.Value.Type is ArrayType) + { + ArrayType arrT = (ArrayType)narg.Value.Type; + if (arrT.ElementType == CoreSystemTypes.Type) + { + signature.Write((byte)ElementType.SzArray); + signature.Write((byte)ElementType.Type); + } + else + this.WriteTypeSignature(signature, narg.Value.Type); + } + else + this.WriteTypeSignature(signature, narg.Value.Type); + signature.Write(narg.Name.Name, false); + this.WriteCustomAttributeLiteral(signature, (Literal)narg.Value, narg.ValueIsBoxed); + } + } + } + int GetBlobIndex(byte[]/*!*/ blob) + { + object indexOb = this.blobHeapIndex[blob]; + if (indexOb != null) return (int)indexOb; + int index = (int)this.blobHeap.BaseStream.Position; + int length = blob.Length; + Ir2md.WriteCompressedInt(this.blobHeap, length); + this.blobHeap.BaseStream.Write(blob, 0, length); + this.blobHeapIndex[blob] = index; + return index; + } + int GetBlobIndex(string/*!*/ str) + { + object indexOb = this.blobHeapStringIndex[str]; + if (indexOb != null) return (int)indexOb; + int index = (int)this.blobHeap.BaseStream.Position; + this.blobHeap.Write((string)str); + this.blobHeapStringIndex[str] = index; + return index; + } + int GetBlobIndex(Field/*!*/ field) + { + if (field != null && field.DeclaringType != null && field.DeclaringType.Template != null && field.DeclaringType.Template.IsGeneric) + field = this.GetUnspecializedField(field); + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + signature.Write((byte)0x6); + TypeNode fieldType = field.Type; +#if ExtendedRuntime + if (field.HasOutOfBandContract) fieldType = TypeNode.DeepStripModifiers(fieldType, null, SystemTypes.NonNullType); +#endif + if (fieldType == null) { Debug.Fail(""); fieldType = SystemTypes.Object; } + this.WriteTypeSignature(signature, fieldType, true); + return this.GetBlobIndex(sig.ToArray()); + } + int GetBlobIndex(MarshallingInformation/*!*/ marshallingInformation) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + signature.Write((byte)marshallingInformation.NativeType); + switch (marshallingInformation.NativeType) + { + case NativeType.SafeArray: + signature.Write((byte)marshallingInformation.ElementType); + if (marshallingInformation.Class != null && marshallingInformation.Class.Length > 0) + signature.Write(marshallingInformation.Class, false); + break; + case NativeType.LPArray: + signature.Write((byte)marshallingInformation.ElementType); + if (marshallingInformation.ParamIndex >= 0 || marshallingInformation.ElementSize > 0) + { + if (marshallingInformation.ParamIndex < 0) + { + Debug.Fail("MarshallingInformation.ElementSize > 0 should imply that ParamIndex >= 0"); + marshallingInformation.ParamIndex = 0; + } + Ir2md.WriteCompressedInt(signature, marshallingInformation.ParamIndex); + } + if (marshallingInformation.ElementSize > 0) + { + Ir2md.WriteCompressedInt(signature, marshallingInformation.ElementSize); + if (marshallingInformation.NumberOfElements > 0) + Ir2md.WriteCompressedInt(signature, marshallingInformation.NumberOfElements); + } + break; + case NativeType.ByValArray: + Ir2md.WriteCompressedInt(signature, marshallingInformation.Size); + if (marshallingInformation.ElementType != NativeType.NotSpecified) + signature.Write((byte)marshallingInformation.ElementType); + break; + case NativeType.ByValTStr: + Ir2md.WriteCompressedInt(signature, marshallingInformation.Size); + break; + case NativeType.CustomMarshaler: + signature.Write((short)0); + signature.Write(marshallingInformation.Class); + signature.Write(marshallingInformation.Cookie); + break; + } + return this.GetBlobIndex(sig.ToArray()); + } + int GetBlobIndex(Literal/*!*/ literal) + { + int index = (int)this.blobHeap.BaseStream.Position; + TypeNode lType = literal.Type; + EnumNode eType = lType as EnumNode; + if (eType != null) lType = eType.UnderlyingType; + IConvertible ic = literal.Value as IConvertible; + if (ic == null) ic = ""; + switch (lType.typeCode) + { + case ElementType.Boolean: this.blobHeap.Write((byte)1); this.blobHeap.Write(ic.ToBoolean(null)); break; + case ElementType.Char: this.blobHeap.Write((byte)2); this.blobHeap.Write(ic.ToChar(null)); break; + case ElementType.Int8: this.blobHeap.Write((byte)1); this.blobHeap.Write(ic.ToSByte(null)); break; + case ElementType.UInt8: this.blobHeap.Write((byte)1); this.blobHeap.Write(ic.ToByte(null)); break; + case ElementType.Int16: this.blobHeap.Write((byte)2); this.blobHeap.Write(ic.ToInt16(null)); break; + case ElementType.UInt16: this.blobHeap.Write((byte)2); this.blobHeap.Write(ic.ToUInt16(null)); break; + case ElementType.Int32: this.blobHeap.Write((byte)4); this.blobHeap.Write(ic.ToInt32(null)); break; + case ElementType.UInt32: this.blobHeap.Write((byte)4); this.blobHeap.Write(ic.ToUInt32(null)); break; + case ElementType.Int64: this.blobHeap.Write((byte)8); this.blobHeap.Write(ic.ToInt64(null)); break; + case ElementType.UInt64: this.blobHeap.Write((byte)8); this.blobHeap.Write(ic.ToUInt64(null)); break; + case ElementType.Single: this.blobHeap.Write((byte)4); this.blobHeap.Write(ic.ToSingle(null)); break; + case ElementType.Double: this.blobHeap.Write((byte)8); this.blobHeap.Write(ic.ToDouble(null)); break; + case ElementType.String: this.blobHeap.Write((string)literal.Value, false); break; + case ElementType.Array: + case ElementType.Class: + case ElementType.Object: + case ElementType.Reference: + case ElementType.SzArray: this.blobHeap.Write((byte)4); this.blobHeap.Write((int)0); break; //REVIEW: standard implies this should be 0, peverify thinks otherwise. + default: Debug.Assert(false, "Unexpected Literal type"); return 0; + } + return index; + } + int GetBlobIndex(FunctionPointer/*!*/ fp) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + this.WriteMethodSignature(signature, fp); + return this.GetBlobIndex(sig.ToArray()); + } + int GetBlobIndex(Method/*!*/ method, bool methodSpecSignature) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + if (methodSpecSignature) + this.WriteMethodSpecSignature(signature, method); + else + this.WriteMethodSignature(signature, method); + return this.GetBlobIndex(sig.ToArray()); + } + int GetBlobIndex(AttributeList/*!*/ securityAttributes) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + signature.Write((byte)'.'); + Ir2md.WriteCompressedInt(signature, securityAttributes.Count); + foreach (AttributeNode attr in securityAttributes) + this.WriteSecurityAttribute(signature, attr); + return this.GetBlobIndex(sig.ToArray()); + } + private void WriteSecurityAttribute(BinaryWriter signature, AttributeNode attr) + { + this.WriteSerializedTypeName(signature, attr.Type); + MemoryStream sig = new MemoryStream(); + BinaryWriter casig = new BinaryWriter(sig); + MemberBinding mb = attr.Constructor as MemberBinding; + if (mb == null) return; + InstanceInitializer constructor = mb.BoundMember as InstanceInitializer; + if (constructor == null) return; + this.WriteCustomAttributeSignature(attr.Expressions, constructor.Parameters, true, casig); + byte[] sigBytes = sig.ToArray(); + int length = sigBytes.Length; + Ir2md.WriteCompressedInt(signature, length); + signature.BaseStream.Write(sigBytes, 0, length); + } + int GetBlobIndex(Property/*!*/ prop) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + this.WritePropertySignature(signature, prop); + return this.GetBlobIndex(sig.ToArray()); + } + int GetBlobIndex(TypeNode/*!*/ type) + { + MemoryStream sig = new MemoryStream(); + BinaryWriter signature = new BinaryWriter(sig); + this.WriteTypeSignature(signature, type, true); + return this.GetBlobIndex(sig.ToArray()); + } + int GetCustomAttributeParentCodedIndex(Node/*!*/ node) + { + switch (node.NodeType) + { + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + case NodeType.Method: return this.GetMethodIndex((Method)node) << 5; + case NodeType.Field: return (this.GetFieldIndex((Field)node) << 5) | 1; + case NodeType.Parameter: return (this.GetParamIndex((Parameter)node) << 5) | 4; + case NodeType.Class: + case NodeType.DelegateNode: + case NodeType.EnumNode: + case NodeType.Interface: + case NodeType.Struct: +#if !MinimalReader + case NodeType.TupleType: + case NodeType.TypeAlias: + case NodeType.TypeIntersection: + case NodeType.TypeUnion: +#endif + TypeNode t = (TypeNode)node; + if (this.IsStructural(t) && (!t.IsGeneric || (t.Template != null && t.ConsolidatedTemplateArguments != null && t.ConsolidatedTemplateArguments.Count > 0))) + return (this.GetTypeSpecIndex(t) << 5) | 13; + else + return (this.GetTypeDefIndex(t) << 5) | 3; + case NodeType.ClassParameter: + case NodeType.TypeParameter: + if (!this.UseGenerics) goto case NodeType.Class; + return (this.GetGenericParamIndex((TypeNode)node) << 5) | 19; + case NodeType.Property: return (this.GetPropertyIndex((Property)node) << 5) | 9; + case NodeType.Event: return (this.GetEventIndex((Event)node) << 5) | 10; + case NodeType.Module: return (1 << 5) | 7; + case NodeType.Assembly: return (1 << 5) | 14; + default: Debug.Assert(false, "Unexpect custom attribute parent"); return 0; + } + } +#if !ROTOR + ISymUnmanagedDocumentWriter GetDocumentWriter(Document/*!*/ doc) + //^ requires this.symWriter != null; + { + int key = Identifier.For(doc.Name).UniqueIdKey; + object writer = this.documentMap[key]; + if (writer == null) + { + writer = this.symWriter.DefineDocument(doc.Name, ref doc.Language, ref doc.LanguageVendor, ref doc.DocumentType); + this.documentMap[key] = writer; + } + return (ISymUnmanagedDocumentWriter)writer; + } +#endif + int GetEventIndex(Event/*!*/ e) + { + return (int)this.eventIndex[e.UniqueKey]; + } + int GetFieldIndex(Field/*!*/ f) + { + Object index = this.fieldIndex[f.UniqueKey]; + if (index == null) + { + if (this.fieldEntries == null) return 1; + index = this.fieldEntries.Count + 1; + this.fieldEntries.Add(f); + this.fieldIndex[f.UniqueKey] = index; + if (f.DefaultValue != null && !(f.DefaultValue.Value is Parameter)) + this.constantTableEntries.Add(f); + if (!f.IsStatic && f.DeclaringType != null && (f.DeclaringType.Flags & TypeFlags.ExplicitLayout) != 0) + this.fieldLayoutEntries.Add(f); + if ((f.Flags & FieldFlags.HasFieldRVA) != 0) + this.fieldRvaEntries.Add(f); + if (f.MarshallingInformation != null) + this.marshalEntries.Add(f); + } + return (int)index; + } + int GetGenericParamIndex(TypeNode/*!*/ gp) + { + return (int)this.genericParamIndex[gp.UniqueKey]; + } + int GetFieldToken(Field/*!*/ f) + { + if (f.DeclaringType == null || (f.DeclaringType.DeclaringModule == this.module && !this.IsStructural(f.DeclaringType))) + return 0x04000000 | this.GetFieldIndex(f); + else + return 0x0a000000 | this.GetMemberRefIndex(f); + } + bool IsStructural(TypeNode type) + { + if (type == null) return false; + if (this.UseGenerics && (type.IsGeneric || type.Template != null && type.Template.IsGeneric)) return true; + switch (type.NodeType) + { + case NodeType.ArrayType: + case NodeType.Pointer: + case NodeType.Reference: + case NodeType.OptionalModifier: + case NodeType.RequiredModifier: + return true; + case NodeType.ClassParameter: + case NodeType.TypeParameter: + return this.UseGenerics; + } + return false; + } + int GetFileTableIndex(Module/*!*/ module) + { + Object index = this.fileTableIndex[module]; + if (index == null) + { + index = this.fileTableEntries.Count + 1; + this.fileTableEntries.Add(module); + this.fileTableIndex[module] = index; + } + return (int)index; + } + int GetGuidIndex(Guid guid) + { + Object index = this.guidIndex[guid]; + if (index == null) + { + index = this.guidEntries.Count + 1; + this.guidEntries.Add(guid); + this.guidIndex[guid] = index; + } + return (int)index; + } + internal int GetLocalVarIndex(Local/*!*/ loc) + { +#if !MinimalReader + LocalBinding lb = loc as LocalBinding; + if (lb != null) loc = lb.BoundLocal; +#endif + if (this.StripOptionalModifiersFromLocals) + loc.Type = TypeNode.StripModifiers(loc.Type); + MethodInfo methInfo = this.methodInfo; + + if (methInfo.localVarSignature == null) + { + methInfo.localVarSignature = new BinaryWriter(new MemoryStream()); + methInfo.localVarSignature.Write((short)0); + methInfo.localVarIndex = new TrivialHashtable(); + methInfo.localVarSigTok = 0x11000000 | this.GetStandAloneSignatureIndex(methInfo.localVarSignature); + } + object index = methInfo.localVarIndex[loc.UniqueKey]; + if (index == null) + { + methInfo.localVarIndex[loc.UniqueKey] = index = methInfo.localVarIndex.Count; +#if !ROTOR + int startPosition = 0; + if (this.symWriter != null && loc.Name != null && loc.Name.UniqueIdKey != Identifier.Empty.UniqueIdKey) + { + methInfo.debugLocals.Add(loc); + methInfo.signatureOffsets.Add(startPosition = methInfo.localVarSignature.BaseStream.Position); + if (loc.Pinned) methInfo.localVarSignature.Write((byte)ElementType.Pinned); + this.WriteTypeSignature(methInfo.localVarSignature, loc.Type, true); + methInfo.signatureLengths.Add(methInfo.localVarSignature.BaseStream.Position - startPosition); + } + else + { +#endif + if (loc.Pinned) methInfo.localVarSignature.Write((byte)ElementType.Pinned); + this.WriteTypeSignature(methInfo.localVarSignature, loc.Type, true); +#if !ROTOR + } +#endif + } + return (int)index; + } + int GetMemberRefParentEncoded(TypeNode type) + { + if (type == null) return 0; + if (this.IsStructural(type)) return (this.GetTypeSpecIndex(type) << 3) | 4; + if (type.DeclaringModule == this.module) return this.GetTypeDefIndex(type) << 3; + if (type.DeclaringModule != null) return (this.GetTypeRefIndex(type) << 3) | 1; + if (type.typeCode == ElementType.Class || type.typeCode == ElementType.ValueType) + return this.GetTypeDefIndex(type) << 3; //REVIEW: when does this happen? + Debug.Assert(false); + return 0; + } + int GetMemberRefIndex(Member/*!*/ m) + { + Object index = this.memberRefIndex[m.UniqueKey]; + if (index == null) + { + index = this.memberRefEntries.Count + 1; + this.memberRefEntries.Add(m); + this.memberRefIndex[m.UniqueKey] = index; + TypeNode type = m.DeclaringType; + this.VisitReferencedType(type); + } + return (int)index; + } + class VarargMethodCallSignature : FunctionPointer + { + internal Method method; + internal VarargMethodCallSignature(Method/*!*/ method, TypeNodeList/*!*/ parameterTypes) + : base(parameterTypes, method.ReturnType, method.Name) + { + this.method = method; + this.DeclaringType = method.DeclaringType; + } + } + int GetMemberRefToken(Method/*!*/ m, ExpressionList arguments) + { + int numArgs = arguments == null ? 0 : arguments.Count; + TypeNodeList parTypes = new TypeNodeList(numArgs); + int varArgStart = m.Parameters.Count; + for (int i = 0; i < varArgStart; i++) + parTypes.Add(m.Parameters[i].Type); + for (int i = varArgStart; i < numArgs; i++) + { + //^ assert arguments != null; + parTypes.Add(arguments[i].Type); + } + VarargMethodCallSignature sig = new VarargMethodCallSignature(m, parTypes); + sig.VarArgStart = varArgStart; + sig.CallingConvention = m.CallingConvention; + return 0x0a000000 | this.GetMemberRefIndex(sig); + } + int GetMethodDefOrRefEncoded(Method/*!*/ m) + { + if (m.DeclaringType.DeclaringModule == this.module && !this.IsStructural(m.DeclaringType)) + return this.GetMethodIndex(m) << 1; + else + return (this.GetMemberRefIndex(m) << 1) | 0x1; + } + int GetMethodIndex(Method/*!*/ m) + { + Object index = this.methodIndex[m.UniqueKey]; + if (index == null) + { + if (this.methodEntries == null) return 1; + index = this.methodEntries.Count + 1; + this.methodEntries.Add(m); + this.methodIndex[m.UniqueKey] = index; + if (m.ReturnTypeMarshallingInformation != null || (m.ReturnAttributes != null && m.ReturnAttributes.Count > 0)) + { + Parameter p = new Parameter(); + p.ParameterListIndex = -1; + p.Attributes = m.ReturnAttributes; + if (m.ReturnTypeMarshallingInformation != null) + { + p.MarshallingInformation = m.ReturnTypeMarshallingInformation; + p.Flags = ParameterFlags.HasFieldMarshal; + this.marshalEntries.Add(p); + } + this.paramEntries.Add(p); + this.paramIndex[m.UniqueKey] = this.paramEntries.Count; + this.paramIndex[p.UniqueKey] = this.paramEntries.Count; + this.VisitAttributeList(p.Attributes, p); + } + int offset = m.IsStatic ? 0 : 1; + if (m.Parameters != null) + { + for (int i = 0, n = m.Parameters.Count; i < n; i++) + { + Parameter p = m.Parameters[i]; + if (p == null) continue; + if (p == null) continue; + if (p.DeclaringMethod == null) p.DeclaringMethod = m; + p.ParameterListIndex = i; + p.ArgumentListIndex = i + offset; + int j = this.paramEntries.Count + 1; + this.paramEntries.Add(p); //TODO: provide a way to suppress the param table entries unless param has custom attributes or flags + this.paramIndex[p.UniqueKey] = j; + if (p.DefaultValue != null) + this.constantTableEntries.Add(p); + if (p.MarshallingInformation != null) + this.marshalEntries.Add(p); + } + } + if (m.IsGeneric) + this.VisitGenericParameterList(m, m.TemplateParameters); + } + return (int)index; + } + int GetMethodSpecIndex(Method/*!*/ m) + { + int structuralKey = m.UniqueKey; + int blobIndex = this.GetBlobIndex(m, true); + if (m.Template != null) + structuralKey = (m.Template.UniqueKey << 8) + blobIndex; + else + Debug.Assert(false); + Object index = this.methodSpecIndex[m.UniqueKey]; + if (index == null) + { + index = this.methodSpecIndex[structuralKey]; + if (index is int) + { + Method otherMethod = this.methodSpecEntries[((int)index) - 1]; + if (otherMethod != null && otherMethod.Template == m.Template && blobIndex == this.GetBlobIndex(otherMethod, true)) + return (int)index; + } + index = this.methodSpecEntries.Count + 1; + this.methodSpecEntries.Add(m); + this.methodSpecIndex[m.UniqueKey] = index; + this.methodSpecIndex[structuralKey] = index; + this.GetMemberRefIndex(m.Template); + Method templ = m.Template; + if (templ != null) + { + while (templ.Template != null) templ = templ.Template; + TypeNodeList templParams = templ.TemplateParameters; + if (templParams != null) + { + for (int i = 0, n = templParams.Count; i < n; i++) + { + TypeNode templParam = templParams[i]; + if (templParam == null) continue; + this.typeParameterNumber[templParam.UniqueKey] = -(i + 1); + } + } + } + } + return (int)index; + } + int GetMethodToken(Method/*!*/ m) + { + if (this.UseGenerics && m.Template != null && m.Template.IsGeneric) + return 0x2b000000 | this.GetMethodSpecIndex(m); + else if (m.DeclaringType.DeclaringModule == this.module && !this.IsStructural(m.DeclaringType)) + return 0x06000000 | this.GetMethodIndex(m); + else + return 0x0a000000 | this.GetMemberRefIndex(m); + } + int GetMethodDefToken(Method/*!*/ m) + { + if (m.DeclaringType.DeclaringModule == this.module) + return 0x06000000 | this.GetMethodIndex(m); + else + return 0x0a000000 | this.GetMemberRefIndex(m); + } + int GetMethodBodiesHeapIndex(Method/*!*/ m) + { + return (int)this.methodBodiesHeapIndex[m.UniqueKey]; + } + int GetModuleRefIndex(Module/*!*/ module) + { + if (module.Location == "unknown:location") throw new InvalidOperationException(ExceptionStrings.UnresolvedModuleReferenceNotAllowed); + Object index = this.moduleRefIndex[module.Name]; + if (index == null) + { + index = this.moduleRefEntries.Count + 1; + this.moduleRefEntries.Add(new ModuleReference(module.Name, module)); + this.moduleRefIndex[module.Name] = index; + if (module.HashValue != null && module.HashValue.Length > 0) + this.GetFileTableIndex(module); + } + return (int)index; + } + int GetOffset(Block target, int addressOfNextInstruction) + { + if (target == null) return 0; + int fixupLocation = (int)(this.methodBodyHeap.BaseStream.Position); + Object ob = this.methodInfo.fixupIndex[target.UniqueKey]; + if (ob is int) return ((int)ob) - addressOfNextInstruction; + Fixup fixup = new Fixup(); + fixup.addressOfNextInstruction = addressOfNextInstruction; + fixup.fixupLocation = fixupLocation; + fixup.shortOffset = false; + fixup.nextFixUp = (Fixup)ob; + this.methodInfo.fixupIndex[target.UniqueKey] = fixup; + return 0; + } + int GetOffset(Block target, ref bool shortOffset) + { + if (target == null) return 0; + int fixupLocation = (int)(this.methodBodyHeap.BaseStream.Position + 1); + Object ob = this.methodInfo.fixupIndex[target.UniqueKey]; + if (ob is int) + { + int targetAddress = (int)ob; + int offset = targetAddress - (fixupLocation + 1); + if (-128 > offset || offset > 127) + { + offset = targetAddress - (fixupLocation + 4); + Debug.Assert(offset < -128, "Forward short branch out of range"); + shortOffset = false; + } + else + shortOffset = true; + return offset; + } + Fixup fixup = new Fixup(); + fixup.fixupLocation = fixup.addressOfNextInstruction = fixupLocation; + if (shortOffset) fixup.addressOfNextInstruction += 1; else fixup.addressOfNextInstruction += 4; + fixup.shortOffset = shortOffset; + fixup.nextFixUp = (Fixup)ob; + this.methodInfo.fixupIndex[target.UniqueKey] = fixup; + return 0; + } + int GetParamIndex(Parameter p) + { + if (p == null) return 0; +#if !MinimalReader + ParameterBinding pb = p as ParameterBinding; + if (pb != null) p = pb.BoundParameter; +#endif + return (int)this.paramIndex[p.UniqueKey]; + } + int GetPropertyIndex(Property/*!*/ p) + { + return (int)this.propertyIndex[p.UniqueKey]; + } + int GetSecurityAttributeParentCodedIndex(Node/*!*/ node) + { + switch (node.NodeType) + { + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + case NodeType.Method: return (this.GetMethodIndex((Method)node) << 2) | 1; + case NodeType.Class: + case NodeType.Interface: + case NodeType.DelegateNode: + case NodeType.EnumNode: + case NodeType.Struct: return (this.GetTypeDefIndex((TypeNode)node) << 2) | 0; + case NodeType.Assembly: return (1 << 2) | 2; + default: Debug.Assert(false, "Unexpected security attribute parent"); return 0; + } + } + int GetStandAloneSignatureIndex(BinaryWriter signatureWriter) + { + this.standAloneSignatureEntries.Add(signatureWriter); + return this.standAloneSignatureEntries.Count; + } + int GetStaticDataIndex(byte[] data, PESection targetSection) + { + int result = 0; + switch (targetSection) + { + case PESection.SData: + result = (int)this.sdataHeap.BaseStream.Position; + this.sdataHeap.Write(data); + break; + case PESection.Text: + result = (int)this.methodBodiesHeap.BaseStream.Position; + this.methodBodiesHeap.Write(data); + break; + case PESection.TLS: + result = (int)this.tlsHeap.BaseStream.Position; + this.tlsHeap.Write(data); + break; + } + return result; + } + int GetResourceDataIndex(byte[]/*!*/ data) + { + int index = (int)this.resourceDataHeap.BaseStream.Position; + this.resourceDataHeap.Write((int)data.Length); + this.resourceDataHeap.Write(data); + return index; + } + int GetStringIndex(string str) + { + if (str == null || str.Length == 0) return 0; + Object index = this.stringHeapIndex[str]; + if (index == null) + { + index = (int)this.stringHeap.BaseStream.Position; + this.stringHeap.Write(str, true); + this.stringHeapIndex[str] = index; + } + return (int)index; + } + int GetUserStringIndex(string/*!*/ str) + { + Object index = this.userStringHeapIndex[str]; + if (index == null) + { + index = (int)this.userStringHeap.BaseStream.Position; + Ir2md.WriteCompressedInt(this.userStringHeap, str.Length * 2 + 1); + this.userStringHeap.Write(str.ToCharArray()); + this.userStringHeapIndex[str] = index; + //Write out a trailing byte indicating if the string is really quite simple + ulong stringKind = 0; //no funny business + foreach (char ch in str) + { + if (ch >= 0x7F) stringKind += 1; + else + switch ((int)ch) + { + case 0x1: + case 0x2: + case 0x3: + case 0x4: + case 0x5: + case 0x6: + case 0x7: + case 0x8: + case 0xE: + case 0xF: + case 0x10: + case 0x11: + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1A: + case 0x1B: + case 0x1C: + case 0x1D: + case 0x1E: + case 0x1F: + case 0x27: + case 0x2D: + stringKind += 1; + break; + default: + break; + } + } + if (stringKind > 0) stringKind = 1; + this.userStringHeap.Write((byte)stringKind); + } + return (int)index; + } + int GetTypeDefIndex(TypeNode/*!*/ type) + { + Object index = this.typeDefIndex[type.UniqueKey]; + if (index == null) + { + if (this.typeDefEntries == null) return 0; + index = this.typeDefEntries.Count + 1; + this.typeDefEntries.Add(type); + this.typeDefIndex[type.UniqueKey] = index; + if (type.IsGeneric && type.Template == null) + this.VisitGenericParameterList(type, type.ConsolidatedTemplateParameters); + } + return (int)index; + } + int GetTypeDefOrRefOrSpecEncoded(TypeNode type) + { + if (type == null) return 0; + if (!this.UseGenerics) + { + ClassParameter cp = type as ClassParameter; + if (cp != null) { Debug.Assert(!cp.IsGeneric); return this.GetTypeDefOrRefOrSpecEncoded(cp.BaseClass); } //REVIEW: why??? + } + if (this.IsStructural(type)) return (this.GetTypeSpecIndex(type) << 2) | 2; + if (type.DeclaringModule == this.module) return this.GetTypeDefIndex(type) << 2; + return (this.GetTypeRefIndex(type) << 2) | 1; + } + int GetTypeToken(TypeNode/*!*/ type) + { + if (this.IsStructural(type) && (!type.IsGeneric || (type.ConsolidatedTemplateArguments != null && type.ConsolidatedTemplateArguments.Count > 0))) + return 0x1b000000 | this.GetTypeSpecIndex(type); + if (type.IsGeneric) + { + TypeNode foundType = type.GetTemplateInstance(type, type.TemplateParameters); + Debug.Assert(foundType != type); + return this.GetTypeToken(foundType); + } + if (type.DeclaringModule == this.module) + return 0x02000000 | this.GetTypeDefIndex(type); + else if (type.DeclaringModule != null) + return 0x01000000 | this.GetTypeRefIndex(type); + else if (type.typeCode == ElementType.ValueType || type.typeCode == ElementType.Class) + { + type.DeclaringModule = this.module; + return 0x02000000 | this.GetTypeDefIndex(type); + } + Debug.Assert(false); + return 0; + } + int GetTypeDefToken(TypeNode/*!*/ type) + { + if (this.IsStructural(type) && (!type.IsGeneric || (type.Template != null && type.ConsolidatedTemplateArguments != null && type.ConsolidatedTemplateArguments.Count > 0))) + return 0x1b000000 | this.GetTypeSpecIndex(type); + if (type.DeclaringModule == this.module) + return 0x02000000 | this.GetTypeDefIndex(type); + else if (type.DeclaringModule != null) + return 0x01000000 | this.GetTypeRefIndex(type); + else if (type.typeCode == ElementType.ValueType || type.typeCode == ElementType.Class) + { + type.DeclaringModule = this.module; + return 0x02000000 | this.GetTypeDefIndex(type); + } + Debug.Assert(false); + return 0; + } + int GetTypeRefIndex(TypeNode/*!*/ type) + { + Object index = this.typeRefIndex[type.UniqueKey]; + if (index == null) + { + index = this.typeRefEntries.Count + 1; + this.typeRefEntries.Add(type); + this.typeRefIndex[type.UniqueKey] = index; + Module module = type.DeclaringModule; + AssemblyNode assembly = module as AssemblyNode; + if (assembly != null) + this.GetAssemblyRefIndex(assembly); + else + this.GetModuleRefIndex(module); + if (type.DeclaringType != null) + this.GetTypeRefIndex(type.DeclaringType); + } + return (int)index; + } + int GetTypeSpecIndex(TypeNode/*!*/ type) + { + int structuralKey = type.UniqueKey; + int blobIndex = 0; + if (type.Template != null) + { + blobIndex = this.GetBlobIndex(type); + structuralKey = ((type.Template.UniqueKey << 8) & int.MaxValue) + blobIndex; + } + Object index = this.typeSpecIndex[type.UniqueKey]; + if (index == null) + { + if (type.Template != null) + { + index = this.typeSpecIndex[structuralKey]; + if (index is int) + { + TypeNode otherType = this.typeSpecEntries[((int)index) - 1]; + if (otherType != null && otherType.Template == type.Template && blobIndex == this.GetBlobIndex(otherType)) + return (int)index; + } + } + index = this.typeSpecEntries.Count + 1; + this.typeSpecEntries.Add(type); + this.typeSpecIndex[type.UniqueKey] = index; + if (type.Template != null) + this.typeSpecIndex[structuralKey] = index; + if (type.Template != null) + { + if (type.Template.DeclaringModule != this.module) + this.GetTypeRefIndex(type.Template); + TypeNodeList templArgs = type.ConsolidatedTemplateArguments; + for (int i = 0, n = templArgs == null ? 0 : templArgs.Count; i < n; i++) + { + this.VisitReferencedType(templArgs[i]); + } + } + else + { + TypeNodeList telems = type.StructuralElementTypes; + for (int i = 0, n = telems == null ? 0 : telems.Count; i < n; i++) + this.VisitReferencedType(telems[i]); + } + } + return (int)index; + } + TrivialHashtable/*!*/ unspecializedFieldFor = new TrivialHashtable(); + Field/*!*/ GetUnspecializedField(Field/*!*/ field) + { + if (field == null || field.DeclaringType == null || !field.DeclaringType.IsGeneric) { Debug.Fail(""); return field; } + Field unspecializedField = (Field)this.unspecializedFieldFor[field.UniqueKey]; + if (unspecializedField != null) return unspecializedField; + TypeNode template = field.DeclaringType; + if (template == null) { Debug.Assert(false); return field; } + while (template.Template != null) template = template.Template; + MemberList specializedMembers = field.DeclaringType.Members; + MemberList unspecializedMembers = template.Members; + for (int i = 0, n = specializedMembers.Count; i < n; i++) + { + if (specializedMembers[i] != field) continue; + unspecializedField = (Field)unspecializedMembers[i]; + if (unspecializedField == null) { Debug.Fail(""); unspecializedField = field; } + this.unspecializedFieldFor[field.UniqueKey] = unspecializedField; + this.VisitReferencedType(unspecializedField.DeclaringType); + return unspecializedField; + } + Debug.Fail(""); + return field; + } + TrivialHashtable/*!*/ unspecializedMethodFor = new TrivialHashtable(); + Method/*!*/ GetUnspecializedMethod(Method/*!*/ method) + { + Debug.Assert(method != null && method.DeclaringType != null && method.DeclaringType.IsGeneric); + Method unspecializedMethod = (Method)this.unspecializedMethodFor[method.UniqueKey]; + if (unspecializedMethod != null) return unspecializedMethod; + TypeNode template = method.DeclaringType; + if (template == null) { Debug.Assert(false); return method; } + while (template.Template != null) template = template.Template; + MemberList specializedMembers = method.DeclaringType.Members; + MemberList unspecializedMembers = template.Members; + for (int i = 0, n = specializedMembers.Count; i < n; i++) + { + if (specializedMembers[i] != method) continue; + unspecializedMethod = unspecializedMembers[i] as Method; + if (unspecializedMethod == null) break; + this.unspecializedMethodFor[method.UniqueKey] = unspecializedMethod; + template = unspecializedMethod.DeclaringType; + while (template.Template != null) template = template.Template; + this.VisitReferencedType(template); + for (int j = 0, m = unspecializedMethod.TemplateParameters == null ? 0 : unspecializedMethod.TemplateParameters.Count; j < m; j++) + { + TypeNode p = unspecializedMethod.TemplateParameters[j]; + if (p == null) continue; + this.typeParameterNumber[p.UniqueKey] = -(j + 1); + } + return unspecializedMethod; + } + Debug.Assert(false); + return method; + } + internal void IncrementStackHeight() + { + this.stackHeight++; + if (this.stackHeight > this.stackHeightMax) this.stackHeightMax = this.stackHeight; + } + void PopulateAssemblyTable() + //^ requires this.assembly != null; + { + AssemblyNode assembly = this.assembly; + AssemblyRow[] assemblyTable = this.writer.assemblyTable = new AssemblyRow[1]; + assemblyTable[0].HashAlgId = (int)AssemblyHashAlgorithm.SHA1; + assemblyTable[0].Flags = (int)assembly.Flags; + if (assembly.Version == null) assembly.Version = new Version(1, 0, 0, 0); + assemblyTable[0].MajorVersion = assembly.Version.Major; + assemblyTable[0].MinorVersion = assembly.Version.Minor; + assemblyTable[0].RevisionNumber = assembly.Version.Revision; + assemblyTable[0].BuildNumber = assembly.Version.Build; + if (assembly.PublicKeyOrToken != null && 0 < assembly.PublicKeyOrToken.Length) + assemblyTable[0].PublicKey = this.GetBlobIndex(assembly.PublicKeyOrToken); + if (assembly.Name != null) + assemblyTable[0].Name = this.GetStringIndex(assembly.Name); + else + Debug.Assert(false, "Assembly must have a name"); + if (assembly.Culture != null && assembly.Culture.Length > 0) + assemblyTable[0].Culture = this.GetStringIndex(assembly.Culture); + this.writer.assemblyTable = assemblyTable; + } + void PopulateAssemblyRefTable() + { + AssemblyReferenceList arList = this.module.AssemblyReferences = this.assemblyRefEntries; + if (arList == null) return; + int n = arList.Count; + AssemblyRefRow[] arRows = this.writer.assemblyRefTable = new AssemblyRefRow[n]; + for (int i = 0; i < n; i++) + { + AssemblyReference ar = arList[i]; + if (ar.Version == null) + Debug.Assert(false, "assembly reference without a version"); + else + { + arRows[i].MajorVersion = ar.Version.Major; + arRows[i].MinorVersion = ar.Version.Minor; + arRows[i].RevisionNumber = ar.Version.Revision; + arRows[i].BuildNumber = ar.Version.Build; + arRows[i].Flags = (int)ar.Flags; + } + if (ar.PublicKeyOrToken != null && 0 < ar.PublicKeyOrToken.Length) + arRows[i].PublicKeyOrToken = this.GetBlobIndex(ar.PublicKeyOrToken); + if (ar.Name == null) + Debug.Assert(false, "assembly reference without a name"); + else + arRows[i].Name = this.GetStringIndex(ar.Name); + if (ar.Culture != null && ar.Culture.Length > 0) + arRows[i].Culture = this.GetStringIndex(ar.Culture); + if (ar.HashValue != null) + arRows[i].HashValue = this.GetBlobIndex(ar.HashValue); + } + //this.assemblyRefEntries = null; + } + void PopulateClassLayoutTable() + { + int n = this.classLayoutEntries.Count; + if (n == 0) return; + ClassLayoutRow[] clr = this.writer.classLayoutTable = new ClassLayoutRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode t = this.classLayoutEntries[i]; + clr[i].ClassSize = t.ClassSize; + clr[i].PackingSize = t.PackingSize; + clr[i].Parent = this.GetTypeDefIndex(t); + } + //this.classLayoutEntries = null; + } + void PopulateConstantTable() + { + int n = this.constantTableEntries.Count; + if (n == 0) return; + ConstantRow[] cr = this.writer.constantTable = new ConstantRow[n]; + for (int i = 0; i < n; i++) + { + Parameter p = this.constantTableEntries[i] as Parameter; + if (p != null) + { + cr[i].Parent = (this.GetParamIndex(p) << 2) | 1; + cr[i].Value = this.GetBlobIndex((Literal)p.DefaultValue); + TypeNode t = p.DefaultValue.Type; + if (t.NodeType == NodeType.EnumNode) t = ((EnumNode)t).UnderlyingType; + cr[i].Type = (int)t.typeCode; + if (t is Reference || (t != p.Type && Literal.IsNullLiteral(p.DefaultValue))) + cr[i].Type = (int)ElementType.Class; + } + else + { + Field f = (Field)this.constantTableEntries[i]; + cr[i].Parent = (this.GetFieldIndex(f) << 2); + cr[i].Value = this.GetBlobIndex(f.DefaultValue); + TypeNode t = f.DefaultValue.Type; + if (t.NodeType == NodeType.EnumNode) t = ((EnumNode)t).UnderlyingType; + cr[i].Type = (int)t.typeCode; + if (t is Reference || (t != f.Type && Literal.IsNullLiteral(f.DefaultValue))) + cr[i].Type = (int)ElementType.Class; + } + ConstantRow temp = cr[i]; + int parent = temp.Parent; + for (int j = i - 1; j >= 0; j--) + { + if (cr[j].Parent > parent) + { + cr[j + 1] = cr[j]; + if (j == 0) + { + cr[0] = temp; + break; + } + } + else + { + if (j < i - 1) cr[j + 1] = temp; + break; + } + } + } + //TODO: more efficient sort + //this.constantTableEntries = null; + } + void PopulateCustomAttributeTable() + { + if (this.customAttributeCount == 0) return; + CustomAttributeRow[] table = this.writer.customAttributeTable = new CustomAttributeRow[this.customAttributeCount]; + int k = 0; + int prevCodedIndex = 0; + for (int i = 0, n = this.nodesWithCustomAttributes.Count; i < n; i++) + { + AttributeList attrs = null; + Node node = this.nodesWithCustomAttributes[i]; + int codedIndex = 0; + switch (node.NodeType) + { + case NodeType.Method: + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + Method m = (Method)node; + codedIndex = this.GetMethodIndex(m) << 5; + attrs = m.Attributes; + break; + case NodeType.Field: + Field f = (Field)node; + codedIndex = (this.GetFieldIndex(f) << 5) | 1; + attrs = f.Attributes; + break; + case NodeType.Parameter: + Parameter par = (Parameter)node; + codedIndex = (this.GetParamIndex(par) << 5) | 4; + attrs = par.Attributes; + break; + case NodeType.Class: + case NodeType.DelegateNode: + case NodeType.EnumNode: + case NodeType.Interface: + case NodeType.Struct: +#if !MinimalReader + case NodeType.TupleType: + case NodeType.TypeAlias: + case NodeType.TypeIntersection: + case NodeType.TypeUnion: +#endif + TypeNode t = (TypeNode)node; + if (this.IsStructural(t) && (!t.IsGeneric || (t.Template != null && t.ConsolidatedTemplateArguments != null && t.ConsolidatedTemplateArguments.Count > 0))) + codedIndex = (this.GetTypeSpecIndex(t) << 5) | 13; + else + codedIndex = (this.GetTypeDefIndex(t) << 5) | 3; + attrs = t.Attributes; + break; + case NodeType.ClassParameter: + case NodeType.TypeParameter: + if (!this.UseGenerics) goto case NodeType.Class; + t = (TypeNode)node; + codedIndex = (this.GetGenericParamIndex(t) << 5) | 19; + attrs = t.Attributes; + break; + case NodeType.Property: + Property p = (Property)node; + codedIndex = (this.GetPropertyIndex(p) << 5) | 9; + attrs = p.Attributes; + break; + case NodeType.Event: + Event e = (Event)node; + codedIndex = (this.GetEventIndex(e) << 5) | 10; + attrs = e.Attributes; + break; + case NodeType.Module: + case NodeType.Assembly: + codedIndex = (1 << 5) | (node.NodeType == NodeType.Module ? 7 : 14); + attrs = ((Module)node).Attributes; + break; + default: + Debug.Assert(false); + break; + } + if (attrs == null) continue; + if (UseGenerics) + { + Debug.Assert(codedIndex > prevCodedIndex); + } + prevCodedIndex = codedIndex; + for (int j = 0, m = attrs.Count; j < m; j++) + { + AttributeNode a = attrs[j]; + if (a == null) continue; + table[k].Parent = codedIndex; + Debug.Assert(a.Constructor is MemberBinding); + Method cons = (Method)((MemberBinding)a.Constructor).BoundMember; + if (cons.DeclaringType.DeclaringModule == this.module && !this.IsStructural(cons.DeclaringType)) + table[k].Constructor = (this.GetMethodIndex(cons) << 3) | 2; + else + table[k].Constructor = (this.GetMemberRefIndex(cons) << 3) | 3; + table[k].Value = this.GetBlobIndex(a.Expressions, cons.Parameters); + k++; + } + } + } + void PopulateDeclSecurityTable() + { + if (this.securityAttributeCount == 0) return; + DeclSecurityRow[] table = this.writer.declSecurityTable = new DeclSecurityRow[this.securityAttributeCount]; + int k = 0; + int prevCodedIndex = 0; + for (int i = 0, n = this.nodesWithSecurityAttributes.Count; i < n; i++) + { + SecurityAttributeList attrs = null; + Node node = this.nodesWithSecurityAttributes[i]; + int codedIndex = 0; + switch (node.NodeType) + { + case NodeType.Method: + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + Method m = (Method)node; + codedIndex = (this.GetMethodIndex(m) << 2) | 1; + attrs = m.SecurityAttributes; + break; + case NodeType.Class: + case NodeType.Interface: + case NodeType.DelegateNode: + case NodeType.EnumNode: + case NodeType.Struct: + TypeNode t = (TypeNode)node; + codedIndex = (this.GetTypeDefIndex(t) << 2) | 0; + attrs = t.SecurityAttributes; + break; + case NodeType.Assembly: + codedIndex = (1 << 2) | 2; + attrs = ((AssemblyNode)node).SecurityAttributes; + break; + default: + Debug.Assert(false); + break; + } + if (attrs == null) continue; + Debug.Assert(codedIndex > prevCodedIndex); + prevCodedIndex = codedIndex; + for (int j = 0, m = attrs.Count; j < m; j++) + { + SecurityAttribute a = attrs[j]; + if (a == null) continue; + this.VisitReferencedType(CoreSystemTypes.SecurityAction); + table[k].Action = (int)a.Action; + table[k].Parent = codedIndex; + if (CoreSystemTypes.SystemAssembly.MetadataFormatMajorVersion == 1 && CoreSystemTypes.SystemAssembly.MetadataFormatMinorVersion < 1) + table[k].PermissionSet = this.GetBlobIndex(a.SerializedPermissions); + else + { + if (a.PermissionAttributes != null) + { + table[k].PermissionSet = this.GetBlobIndex(a.PermissionAttributes); + } + else + { + // Came across some assemblies that had a metadata version > 1.0, but still used + // serialized security attributes. So might as well try to see if this is the case + // if the PermissionAttributes are null. + table[k].PermissionSet = this.GetBlobIndex(a.SerializedPermissions); + } + } + k++; + } + } + } + void PopulateEventMapTable() + { + int n = this.eventMapEntries.Count; + if (n == 0) return; + EventMapRow[] emr = this.writer.eventMapTable = new EventMapRow[n]; + for (int i = 0; i < n; i++) + { + Event e = this.eventMapEntries[i]; + emr[i].Parent = this.GetTypeDefIndex(e.DeclaringType); + emr[i].EventList = this.GetEventIndex(e); + } + //this.eventMapEntries = null; + } + void PopulateEventTable() + { + int n = this.eventEntries.Count; + if (n == 0) return; + EventRow[] er = this.writer.eventTable = new EventRow[n]; + for (int i = 0; i < n; i++) + { + Event e = this.eventEntries[i]; + if (e == null || e.Name == null) continue; + er[i].Flags = (int)e.Flags; + er[i].Name = this.GetStringIndex(e.Name.ToString()); + er[i].EventType = this.GetTypeDefOrRefOrSpecEncoded(e.HandlerType); + } + //this.eventEntries = null; + } + void PopulateExportedTypeTable() + { + if (this.assembly == null) return; + TypeNodeList exportedTypes = this.assembly.ExportedTypes; + int n = exportedTypes == null ? 0 : exportedTypes.Count; + if (n == 0) return; + ExportedTypeRow[] ett = this.writer.exportedTypeTable = new ExportedTypeRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode et = exportedTypes[i]; + if (et == null || et.Namespace == null || et.Name == null) continue; + ett[i].TypeDefId = 0; + ett[i].TypeNamespace = this.GetStringIndex(et.Namespace.ToString()); + ett[i].TypeName = this.GetStringIndex(et.Name.ToString()); + ett[i].Flags = (int)(et.Flags & TypeFlags.VisibilityMask); + if (et.DeclaringType != null) + { + for (int j = 0; j < i; j++) + { + if (exportedTypes[j] == et.DeclaringType) + { + ett[i].Implementation = (j << 2) | 2; + break; + } + } + } + else if (et.DeclaringModule != this.module && et.DeclaringModule is AssemblyNode) + { + ett[i].Implementation = (this.GetAssemblyRefIndex((AssemblyNode)et.DeclaringModule) << 2) | 1; + ett[i].Flags = (int)TypeFlags.Forwarder; + } + else + ett[i].Implementation = (this.GetFileTableIndex(et.DeclaringModule) << 2) | 0; + } + } + void PopulateFieldTable() + { + int n = this.fieldEntries.Count; + if (n == 0) return; + FieldRow[] fr = this.writer.fieldTable = new FieldRow[n]; + for (int i = 0; i < n; i++) + { + Field f = this.fieldEntries[i]; + fr[i].Flags = (int)f.Flags; + fr[i].Name = this.GetStringIndex(f.Name.Name); // we don't store prefixes in field names. + fr[i].Signature = this.GetBlobIndex(f); + } + //this.fieldEntries = null; + } + void PopulateFieldLayoutTable() + { + int n = this.fieldLayoutEntries.Count; + if (n == 0) return; + FieldLayoutRow[] flr = this.writer.fieldLayoutTable = new FieldLayoutRow[n]; + for (int i = 0; i < n; i++) + { + Field f = this.fieldLayoutEntries[i]; + flr[i].Field = this.GetFieldIndex(f); + flr[i].Offset = f.Offset; + } + //this.fieldLayoutEntries = null; + } + void PopulateFieldRVATable() + { + int n = this.fieldRvaEntries.Count; + if (n == 0) return; + FieldRvaRow[] frr = this.writer.fieldRvaTable = new FieldRvaRow[n]; + for (int i = 0; i < n; i++) + { + Field f = this.fieldRvaEntries[i]; + frr[i].Field = this.GetFieldIndex(f); + if (f.InitialData != null) + frr[i].RVA = this.GetStaticDataIndex(f.InitialData, f.Section); //Fixed up to be an RVA inside MetadataWriter. + else + frr[i].RVA = f.Offset; + frr[i].TargetSection = f.Section; + } + //this.fieldRvaEntries = null; + } + void PopulateFileTable() + { + int n = this.fileTableEntries.Count; + if (n == 0) return; + bool readContents = false; + FileRow[] ftr = this.writer.fileTable = new FileRow[n]; + for (int i = 0; i < n; i++) + { + Module module = this.fileTableEntries[i]; + switch (module.Kind) + { + case ModuleKindFlags.ConsoleApplication: + case ModuleKindFlags.DynamicallyLinkedLibrary: + case ModuleKindFlags.WindowsApplication: + ftr[i].Flags = (int)FileFlags.ContainsMetaData; + break; + case ModuleKindFlags.ManifestResourceFile: + readContents = true; + ftr[i].Flags = (int)FileFlags.ContainsNoMetaData; + break; + case ModuleKindFlags.UnmanagedDynamicallyLinkedLibrary: + ftr[i].Flags = (int)FileFlags.ContainsNoMetaData; + break; + } + if (module.HashValue != null) + ftr[i].HashValue = this.GetBlobIndex(module.HashValue); + else + ftr[i].HashValue = 0; + ftr[i].Name = this.GetStringIndex(module.Name); + if (readContents) + { + try + { + FileStream fs = File.OpenRead(module.Location); + long size = fs.Length; + byte[] buffer = new byte[size]; + fs.Read(buffer, 0, (int)size); + System.Security.Cryptography.SHA1 sha1 = new System.Security.Cryptography.SHA1CryptoServiceProvider(); + byte[] hash = sha1.ComputeHash(buffer); + ftr[i].HashValue = this.GetBlobIndex(hash); + } + catch { } + } + } + //this.fileTableEntries = null; + } + void PopulateGuidTable() + { + int n = this.guidEntries.Count; + Guid[] guids = this.writer.GuidHeap = new Guid[n]; + for (int i = 0; i < n; i++) + guids[i] = (Guid)this.guidEntries[i]; + //this.guidEntries = null; + } + void PopulateGenericParamTable() + { + int n = this.genericParamEntries.Count; + if (n == 0) return; + GenericParamRow[] gpr = this.writer.genericParamTable = new GenericParamRow[n]; + Member lastMember = null; + int number = 0; + for (int i = 0; i < n; i++) + { + Member m = this.genericParamEntries[i]; + TypeNode paramType = this.genericParameters[i]; + if (paramType == null || paramType.Name == null) continue; + Method meth = m as Method; + TypeNode type = m as TypeNode; + if (m != lastMember) number = 0; + gpr[i].GenericParameter = paramType; + gpr[i].Number = number++; + if (type != null) + { + gpr[i].Name = this.GetStringIndex(paramType.Name.ToString()); + gpr[i].Owner = (this.GetTypeDefIndex(type) << 1) | 0; + } + else + { + //^ assert meth != null; + gpr[i].Name = this.GetStringIndex(paramType.Name.ToString()); + gpr[i].Owner = (this.GetMethodIndex(meth) << 1) | 1; + } + ITypeParameter tp = paramType as ITypeParameter; + if (tp != null) + gpr[i].Flags = (int)tp.TypeParameterFlags; + else + { + Debug.Assert(false); + gpr[i].Flags = 0; + } + lastMember = m; + GenericParamRow temp = gpr[i]; + int owner = temp.Owner; + for (int j = i - 1; j >= 0; j--) + { + if (gpr[j].Owner > owner) + { + gpr[j + 1] = gpr[j]; + if (j == 0) + { + gpr[0] = temp; + break; + } + } + else + { + if (j < i - 1) gpr[j + 1] = temp; + break; + } + } + } + for (int i = 0; i < n; i++) + { + Member genPar = gpr[i].GenericParameter; + if (genPar == null) continue; + this.genericParamIndex[genPar.UniqueKey] = i + 1; + } + for (int i = 0; i < n; i++) + { + Member genPar = gpr[i].GenericParameter; + if (genPar == null) continue; + this.VisitAttributeList(genPar.Attributes, genPar); + } + //this.genericParamEntries = null; + //this.genericParameters = null; + } + void PopulateGenericParamConstraintTable() + { + int n = this.genericParamConstraintEntries.Count; + if (n == 0) return; + GenericParamConstraintRow[] gpcr = this.writer.genericParamConstraintTable = new GenericParamConstraintRow[n]; + TypeNode lastParameter = null; + int paramIndex = 0; + int constraintIndex = 0; + int indexOffset = 0; + for (int i = 0; i < n; i++) + { + TypeNode t = this.genericParamConstraintEntries[i]; + if (t != lastParameter) + { + paramIndex = this.GetGenericParamIndex(t); + constraintIndex = 0; + indexOffset = 0; + } + gpcr[i].Param = paramIndex; + TypeNode constraint; + if (constraintIndex == 0 && t.BaseType != null && t.BaseType != CoreSystemTypes.Object) + { + constraint = t.BaseType; indexOffset = 1; + } + else + constraint = t.Interfaces[constraintIndex - indexOffset]; + gpcr[i].Constraint = this.GetTypeDefOrRefOrSpecEncoded(constraint); + lastParameter = t; + constraintIndex++; + GenericParamConstraintRow temp = gpcr[i]; + int param = temp.Param; + for (int j = i - 1; j >= 0; j--) + { + if (gpcr[j].Param > param) + { + gpcr[j + 1] = gpcr[j]; + if (j == 0) + { + gpcr[0] = temp; + break; + } + } + else + { + if (j < i - 1) gpcr[j + 1] = temp; + break; + } + } + } + //this.genericParamConstraintEntries = null; + } + void PopulateImplMapTable() + { + int n = this.implMapEntries.Count; + if (n == 0) return; + ImplMapRow[] imr = this.writer.implMapTable = new ImplMapRow[n]; + for (int i = 0; i < n; i++) + { + Method m = this.implMapEntries[i]; + imr[i].ImportName = this.GetStringIndex(m.PInvokeImportName); + imr[i].ImportScope = this.GetModuleRefIndex(m.PInvokeModule); + imr[i].MappingFlags = (int)m.PInvokeFlags; + imr[i].MemberForwarded = (this.GetMethodIndex(m) << 1) | 1; + } + //this.implMapEntries = null; + } + void PopulateInterfaceImplTable() + { + int n = this.interfaceEntries.Count; + if (n == 0) return; + InterfaceImplRow[] iir = this.writer.interfaceImplTable = new InterfaceImplRow[n]; + TypeNode prevT = null; + for (int i = 0, j = 0; i < n; i++) + { + TypeNode t = this.interfaceEntries[i]; + if (t == prevT) + j++; + else + { + j = 0; + prevT = t; + } + int ti = iir[i].Class = this.GetTypeDefIndex(t); + Interface iface = null; +#if ExtendedRuntime + if (t is ITypeParameter){ + int numIfaces = t.Interfaces == null ? 0 : t.Interfaces.Count; + if (j == numIfaces) + iface = SystemTypes.ITemplateParameter; + else + iface = t.Interfaces[j]; + }else +#endif + iface = t.Interfaces[j]; + if (iface == null) { i--; continue; } + int ii = iir[i].Interface = this.GetTypeDefOrRefOrSpecEncoded(iface); + for (int k = 0; k < i; k++) + { //REVIEW: is a more efficient sort worthwhile? + if (iir[k].Class > ti) + { + for (int kk = i; kk > k; kk--) + { + iir[kk].Class = iir[kk - 1].Class; + iir[kk].Interface = iir[kk - 1].Interface; + } + iir[k].Class = ti; + iir[k].Interface = ii; + break; + } + } + } + //this.interfaceEntries = null; + } + void PopulateManifestResourceTable() + { + ResourceList resources = this.module.Resources; + int n = resources == null ? 0 : resources.Count; + if (n == 0) return; + ManifestResourceRow[] mresources = this.writer.manifestResourceTable = new ManifestResourceRow[n]; + for (int i = 0; i < n; i++) + { + Resource r = resources[i]; + mresources[i].Flags = r.IsPublic ? 1 : 2; + mresources[i].Name = this.GetStringIndex(r.Name); + if (r.Data != null) + mresources[i].Offset = this.GetResourceDataIndex(r.Data); + else if (r.DefiningModule is AssemblyNode) + mresources[i].Implementation = (this.GetAssemblyRefIndex((AssemblyNode)r.DefiningModule) << 2) | 1; + else + mresources[i].Implementation = (this.GetFileTableIndex(r.DefiningModule) << 2) | 0; + } + } + void PopulateMarshalTable() + { + int n = this.marshalEntries.Count; + if (n == 0) return; + FieldMarshalRow[] fmr = this.writer.fieldMarshalTable = new FieldMarshalRow[n]; + for (int i = 0; i < n; i++) + { + MarshallingInformation mi; + Field f = this.marshalEntries[i] as Field; + if (f != null) + { + fmr[i].Parent = (this.GetFieldIndex(f) << 1) | 0; + mi = f.MarshallingInformation; + } + else + { + Parameter p = (Parameter)this.marshalEntries[i]; + fmr[i].Parent = (this.GetParamIndex(p) << 1) | 1; + mi = p.MarshallingInformation; + } + int nt = fmr[i].NativeType = this.GetBlobIndex(mi); + int pi = fmr[i].Parent; + for (int k = 0; k < i; k++) + { //REVIEW: is a more efficient sort worthwhile? + if (fmr[k].Parent > pi) + { + for (int kk = i; kk > k; kk--) + { + fmr[kk].Parent = fmr[kk - 1].Parent; + fmr[kk].NativeType = fmr[kk - 1].NativeType; + } + fmr[k].Parent = pi; + fmr[k].NativeType = nt; + break; + } + } + } + //this.marshalEntries = null; + } + void PopulateMemberRefTable() + { + int n = this.memberRefEntries.Count; + if (n == 0) return; + MemberRefRow[] mr = this.writer.memberRefTable = new MemberRefRow[n]; + for (int i = 0; i < n; i++) + { + Member member = this.memberRefEntries[i]; + if (member == null || member.Name == null) continue; + mr[i].Name = this.GetStringIndex(member.Name.ToString()); + Field f = member as Field; + if (f != null) + mr[i].Signature = this.GetBlobIndex(f); + else + { + FunctionPointer fp = member as FunctionPointer; + if (fp != null) + { + mr[i].Signature = this.GetBlobIndex(fp); + if (fp is VarargMethodCallSignature) + { + Method m = ((VarargMethodCallSignature)member).method; + if (m != null && m.DeclaringType.DeclaringModule == this.module && !this.IsStructural(m.DeclaringType)) + { + mr[i].Class = (this.GetMethodIndex(m) << 3) | 3; + continue; + } + } + } + else + { + Method m = (Method)member; + if (m.IsGeneric && m.Template != null) m = this.GetUnspecializedMethod(m); + mr[i].Signature = this.GetBlobIndex(m, false); + if (m.DeclaringType.DeclaringModule == this.module && !this.IsStructural(m.DeclaringType) && !m.IsGeneric) + { + mr[i].Class = (this.GetMethodIndex(m) << 3) | 3; + continue; + } + //TODO: if the declaring type is the special global members type of another module, set class to a module ref + } + } + int j = mr[i].Class = this.GetMemberRefParentEncoded(member.DeclaringType); + if ((j & 0x3) == 2) mr[i].Class = (j & ~0x3) | 4; + } + //this.memberRefEntries = null; + } + void PopulateMethodTable() + { + int n = this.methodEntries.Count; + if (n == 0) return; + MethodRow[] mr = this.writer.methodTable = new MethodRow[n]; + for (int i = 0; i < n; i++) + { + Method m = this.methodEntries[i]; + if (m == null || m.Name == null) continue; + if (m.IsAbstract || m.Body == null || m.Body.Statements == null || m.Body.Statements.Count == 0) + mr[i].RVA = -1; + else + mr[i].RVA = this.GetMethodBodiesHeapIndex(m); //Fixed up to be an RVA inside MetadataWriter. + mr[i].Flags = (int)m.Flags; + mr[i].ImplFlags = (int)m.ImplFlags; + mr[i].Name = this.GetStringIndex(m.Name.ToString()); + mr[i].Signature = this.GetBlobIndex(m, false); + if (m.ReturnTypeMarshallingInformation != null || (m.ReturnAttributes != null && m.ReturnAttributes.Count > 0)) + mr[i].ParamList = (int)this.paramIndex[m.UniqueKey]; + else + { + ParameterList pars = m.Parameters; + if (pars != null && pars.Count > 0) + { + Debug.Assert(pars[0] != null && pars[0].DeclaringMethod == m); + mr[i].ParamList = this.GetParamIndex(pars[0]); + } + else + mr[i].ParamList = 0; + } + } + //this.methodEntries = null; + } + void PopulateMethodImplTable() + { + int n = this.methodImplEntries.Count; + if (n == 0) return; + MethodImplRow[] mir = this.writer.methodImplTable = new MethodImplRow[n]; + int j = 0; + Method lastMethod = null; + for (int i = 0; i < n; i++) + { + Method m = this.methodImplEntries[i]; + if (lastMethod != m) j = 0; + mir[i].Class = this.GetTypeDefIndex(m.DeclaringType); + if (m.DeclaringType.DeclaringModule == this.module) + mir[i].MethodBody = this.GetMethodIndex(m) << 1; + else + mir[i].MethodBody = (this.GetMemberRefIndex(m) << 1) | 0x1; + Method im = m.ImplementedInterfaceMethods[j++]; + while (im == null) im = m.ImplementedInterfaceMethods[j++]; + mir[i].MethodDeclaration = this.GetMethodDefOrRefEncoded(im); + lastMethod = m; + } + //this.methodImplEntries = null; + } + void PopulateMethodSpecTable() + { + int n = this.methodSpecEntries.Count; + if (n == 0) return; + MethodSpecRow[] msr = this.writer.methodSpecTable = new MethodSpecRow[n]; + for (int i = 0; i < n; i++) + { + Method m = this.methodSpecEntries[i]; + msr[i].Method = this.GetMethodDefOrRefEncoded(m.Template); + msr[i].Instantiation = this.GetBlobIndex(m, true); + //TODO: sort this and eliminate duplicates. + //Duplicates can arise when methods are instantiated with method parameters from different methods. + //TODO: perhaps this duplication should be prevented by Method.GetTemplateInstance? + } + //this.methodEntries = null; + } + void PopulateMethodSemanticsTable() + { + int n = this.methodSemanticsEntries.Count; + if (n == 0) return; + MethodSemanticsRow[] msr = this.writer.methodSemanticsTable = new MethodSemanticsRow[n]; + Member previousOwner = null; + int index = -1; + for (int i = 0; i < n; i++) + { + Member owner = this.methodSemanticsEntries[i]; + Property ownerProperty = owner as Property; + if (ownerProperty != null) + { + msr[i].Association = (this.GetPropertyIndex(ownerProperty) << 1) | 1; + if (owner != previousOwner) + { + previousOwner = owner; + index = -1; + if (ownerProperty.Getter != null) + { + msr[i].Method = this.GetMethodIndex(ownerProperty.Getter); + msr[i].Semantics = 0x0002; + continue; + } + } + if (index == -1) + { + index = 0; + if (ownerProperty.Setter != null) + { + msr[i].Method = this.GetMethodIndex(ownerProperty.Setter); + msr[i].Semantics = 0x0001; + continue; + } + } + msr[i].Method = this.GetMethodIndex(ownerProperty.OtherMethods[index]); + msr[i].Semantics = 0x0004; + index++; + continue; + } + Event ownerEvent = owner as Event; + if (ownerEvent == null) { Debug.Fail(""); continue; } + msr[i].Association = this.GetEventIndex(ownerEvent) << 1; + if (owner != previousOwner) + { + previousOwner = owner; + index = -2; + if (ownerEvent.HandlerAdder != null) + { + msr[i].Method = this.GetMethodIndex(ownerEvent.HandlerAdder); + msr[i].Semantics = 0x0008; + continue; + } + } + if (index == -2) + { + index = -1; + if (ownerEvent.HandlerRemover != null) + { + msr[i].Method = this.GetMethodIndex(ownerEvent.HandlerRemover); + msr[i].Semantics = 0x0010; + continue; + } + } + if (index == -1) + { + index = 0; + if (ownerEvent.HandlerCaller != null) + { + msr[i].Method = this.GetMethodIndex(ownerEvent.HandlerCaller); + msr[i].Semantics = 0x0020; + continue; + } + } + msr[i].Method = this.GetMethodIndex(ownerEvent.OtherMethods[i]); + msr[i].Semantics = 0x0004; + index++; + continue; + } + System.Array.Sort(msr, new MethodSemanticsRowComparer()); + //this.methodSemanticsEntries = null; + } + class MethodSemanticsRowComparer : IComparer + { + int IComparer.Compare(object x, object y) + { + MethodSemanticsRow xr = (MethodSemanticsRow)x; + MethodSemanticsRow yr = (MethodSemanticsRow)y; + int result = xr.Association - yr.Association; + if (result == 0) result = xr.Method - yr.Method; + return result; + } + } + void PopulateModuleTable() + { + ModuleRow[] mr = this.writer.moduleTable = new ModuleRow[1]; + string name = this.module.Name; + if (this.assembly != null) + { + if (this.assembly.ModuleName != null) + name = this.assembly.ModuleName; + else + { + string extension = ".exe"; + if (this.module.Kind == ModuleKindFlags.DynamicallyLinkedLibrary) extension = ".dll"; + name = name + extension; + } + } + mr[0].Name = this.GetStringIndex(name); + mr[0].Mvid = this.GetGuidIndex(Guid.NewGuid()); + } + void PopulateModuleRefTable() + { + int n = this.moduleRefEntries.Count; + if (n == 0) return; + ModuleRefRow[] mrr = this.writer.moduleRefTable = new ModuleRefRow[n]; + for (int i = 0; i < n; i++) + { + ModuleReference moduleRef = this.moduleRefEntries[i]; + mrr[i].Name = this.GetStringIndex(moduleRef.Name); + } + //this.moduleRefEntries = null; + } + void PopulateNestedClassTable() + { + int n = this.nestedClassEntries.Count; + if (n == 0) return; + NestedClassRow[] ncr = this.writer.nestedClassTable = new NestedClassRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode nt = this.nestedClassEntries[i]; + ncr[i].NestedClass = this.GetTypeDefIndex(nt); + ncr[i].EnclosingClass = this.GetTypeDefIndex(nt.DeclaringType); + } + //this.nestedClassEntries = null; + } + void PopulateParamTable() + { + int n = this.paramEntries.Count; + if (n == 0) return; + ParamRow[] pr = this.writer.paramTable = new ParamRow[n]; + for (int i = 0; i < n; i++) + { + Parameter p = this.paramEntries[i]; + if (p == null) continue; + pr[i].Flags = (int)p.Flags; + pr[i].Sequence = p.ParameterListIndex + 1; + pr[i].Name = p.Name == null ? 0 : this.GetStringIndex(p.Name.ToString()); + } + //this.paramEntries = null; + } + void PopulatePropertyTable() + { + int n = this.propertyEntries.Count; + if (n == 0) return; + PropertyRow[] pr = this.writer.propertyTable = new PropertyRow[n]; + for (int i = 0; i < n; i++) + { + Property p = this.propertyEntries[i]; + if (p == null || p.Name == null) continue; + pr[i].Flags = (int)p.Flags; + pr[i].Name = this.GetStringIndex(p.Name.ToString()); + pr[i].Signature = this.GetBlobIndex(p); + } + //this.propertyEntries = null; + } + void PopulatePropertyMapTable() + { + int n = this.propertyMapEntries.Count; + if (n == 0) return; + PropertyMapRow[] pmr = this.writer.propertyMapTable = new PropertyMapRow[n]; + for (int i = 0; i < n; i++) + { + Property p = this.propertyMapEntries[i]; + pmr[i].Parent = this.GetTypeDefIndex(p.DeclaringType); + pmr[i].PropertyList = this.GetPropertyIndex(p); + } + //this.propertyMapEntries = null; + } + void PopulateStandAloneSigTable() + { + int n = this.standAloneSignatureEntries.Count; + if (n == 0) return; + StandAloneSigRow[] sasr = this.writer.standAloneSigTable = new StandAloneSigRow[n]; + for (int i = 0; i < n; i++) + { + BinaryWriter sigWriter = (BinaryWriter)this.standAloneSignatureEntries[i]; + sasr[i].Signature = this.GetBlobIndex(((MemoryStream)sigWriter.BaseStream).ToArray()); + } + } + void PopulateTypeDefTable() + { + int n = this.typeDefEntries.Count; + if (n == 0) return; + TypeDefRow[] tdr = this.writer.typeDefTable = new TypeDefRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode t = this.typeDefEntries[i]; + if (t == null) continue; + tdr[i].Flags = (int)t.Flags; + tdr[i].Name = this.GetStringIndex(t.Name == null ? "" : t.Name.ToString()); + tdr[i].Namespace = t.Namespace == null ? 0 : this.GetStringIndex(t.Namespace == null ? "" : t.Namespace.ToString()); + tdr[i].Extends = this.GetTypeDefOrRefOrSpecEncoded(t.BaseType); + MemberList members = t.Members; + int m = members.Count; + for (int j = 0; j < m; j++) + { + Member mem = members[j]; + if (mem == null) continue; + if (mem.NodeType == NodeType.Field) + { + tdr[i].FieldList = this.GetFieldIndex((Field)mem); + break; + } + } + for (int j = 0; j < m; j++) + { + Member mem = members[j]; + if (mem == null) continue; + switch (mem.NodeType) + { + case NodeType.Method: + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + tdr[i].MethodList = this.GetMethodIndex((Method)mem); + goto done; + } + } + done: continue; + } + //this.typeDefEntries = null; + } + void PopulateTypeRefTable() + { + int n = this.typeRefEntries.Count; + if (n == 0) return; + TypeRefRow[] trr = this.writer.typeRefTable = new TypeRefRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode t = this.typeRefEntries[i]; + if (t == null || t.Name == null || t.Namespace == null) continue; + trr[i].Name = this.GetStringIndex(t.Name.ToString()); + trr[i].Namespace = this.GetStringIndex(t.Namespace.ToString()); + if (t.DeclaringType == null) + if (t.DeclaringModule is AssemblyNode) + trr[i].ResolutionScope = (this.GetAssemblyRefIndex((AssemblyNode)t.DeclaringModule) << 2) | 2; + else + trr[i].ResolutionScope = (this.GetModuleRefIndex(t.DeclaringModule) << 2) | 1; + else + trr[i].ResolutionScope = (this.GetTypeRefIndex(t.DeclaringType) << 2) | 3; + } + //this.typeRefEntries = null; + } + void PopulateTypeSpecTable() + { + int n = this.typeSpecEntries.Count; + if (n == 0) return; + TypeSpecRow[] tsr = this.writer.typeSpecTable = new TypeSpecRow[n]; + for (int i = 0; i < n; i++) + { + TypeNode t = this.typeSpecEntries[i]; + tsr[i].Signature = this.GetBlobIndex(t); + //TODO: eliminate duplicates + } + //this.typeSpecEntries = null; + } + void Visit(Node node) + { + if (node == null) return; + switch (node.NodeType) + { + case NodeType.AddressDereference: + this.VisitAddressDereference((AddressDereference)node); return; + case NodeType.Arglist: + this.VisitExpression((Expression)node); return; + case NodeType.AssignmentStatement: + this.VisitAssignmentStatement((AssignmentStatement)node); return; +#if !MinimalReader + case NodeType.Base: + this.VisitBase((Base)node); return; +#endif + case NodeType.Block: + this.VisitBlock((Block)node); return; +#if !MinimalReader + case NodeType.BlockExpression: + this.VisitBlockExpression((BlockExpression)node); return; +#endif + case NodeType.Branch: + this.VisitBranch((Branch)node); return; + case NodeType.DebugBreak: + this.VisitStatement((Statement)node); return; + case NodeType.Call: + case NodeType.Calli: + case NodeType.Callvirt: + case NodeType.Jmp: +#if !MinimalReader + case NodeType.MethodCall: +#endif + this.VisitMethodCall((MethodCall)node); return; + case NodeType.Class: + case NodeType.ClassParameter: + this.VisitClass((Class)node); return; + case NodeType.Construct: + this.VisitConstruct((Construct)node); return; + case NodeType.ConstructArray: + this.VisitConstructArray((ConstructArray)node); return; + case NodeType.DelegateNode: + this.VisitDelegateNode((DelegateNode)node); return; + case NodeType.Dup: + this.VisitExpression((Expression)node); return; + case NodeType.EndFilter: + this.VisitEndFilter((EndFilter)node); return; + case NodeType.EndFinally: + this.VisitStatement((Statement)node); return; + case NodeType.EnumNode: + this.VisitEnumNode((EnumNode)node); return; + case NodeType.Event: + this.VisitEvent((Event)node); return; + case NodeType.ExpressionStatement: + this.VisitExpressionStatement((ExpressionStatement)node); return; + case NodeType.Field: + this.VisitField((Field)node); return; + case NodeType.Indexer: + this.VisitIndexer((Indexer)node); return; + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + case NodeType.Method: + this.VisitMethod((Method)node); return; + case NodeType.TypeParameter: + case NodeType.Interface: + this.VisitInterface((Interface)node); return; + case NodeType.Literal: + this.VisitLiteral((Literal)node); return; + case NodeType.Local: + this.VisitLocal((Local)node); return; +#if !MinimalReader + case NodeType.LocalDeclarationsStatement: + this.VisitLocalDeclarationsStatement((LocalDeclarationsStatement)node); return; +#endif + case NodeType.MemberBinding: + this.VisitMemberBinding((MemberBinding)node); return; + case NodeType.Nop: + this.VisitStatement((Statement)node); return; + case NodeType.Parameter: + this.VisitParameter((Parameter)node); return; + case NodeType.Pop: + this.VisitExpression((Expression)node); return; + case NodeType.Property: + this.VisitProperty((Property)node); return; + case NodeType.Rethrow: + case NodeType.Throw: + this.VisitThrow((Throw)node); return; + case NodeType.Return: + this.VisitReturn((Return)node); return; + case NodeType.Struct: +#if !MinimalReader + case NodeType.TypeAlias: + case NodeType.TypeIntersection: + case NodeType.TypeUnion: + case NodeType.TupleType: +#endif + this.VisitStruct((Struct)node); return; +#if !MinimalReader + case NodeType.SwitchCaseBottom: + return; +#endif + case NodeType.SwitchInstruction: + this.VisitSwitchInstruction((SwitchInstruction)node); return; + case NodeType.This: + this.VisitThis((This)node); return; + + case NodeType.Cpblk: + case NodeType.Initblk: + this.VisitTernaryExpression((TernaryExpression)node); return; + + case NodeType.Add: + case NodeType.Add_Ovf: + case NodeType.Add_Ovf_Un: + case NodeType.And: + case NodeType.Box: + case NodeType.Castclass: + case NodeType.Ceq: + case NodeType.Cgt: + case NodeType.Cgt_Un: + case NodeType.Clt: + case NodeType.Clt_Un: + case NodeType.Div: + case NodeType.Div_Un: + case NodeType.Eq: + case NodeType.Ge: + case NodeType.Gt: +#if !MinimalReader + case NodeType.Is: +#endif + case NodeType.Isinst: + case NodeType.Ldvirtftn: + case NodeType.Le: + case NodeType.Lt: + case NodeType.Mkrefany: + case NodeType.Mul: + case NodeType.Mul_Ovf: + case NodeType.Mul_Ovf_Un: + case NodeType.Ne: + case NodeType.Or: + case NodeType.Refanyval: + case NodeType.Rem: + case NodeType.Rem_Un: + case NodeType.Shl: + case NodeType.Shr: + case NodeType.Shr_Un: + case NodeType.Sub: + case NodeType.Sub_Ovf: + case NodeType.Sub_Ovf_Un: + case NodeType.Unbox: + case NodeType.UnboxAny: + case NodeType.Xor: + this.VisitBinaryExpression((BinaryExpression)node); return; + + + case NodeType.AddressOf: +#if !MinimalReader + case NodeType.OutAddress: + case NodeType.RefAddress: +#endif + case NodeType.ReadOnlyAddressOf: + this.VisitAddressOf((UnaryExpression)node); return; + case NodeType.Ckfinite: + case NodeType.Conv_I: + case NodeType.Conv_I1: + case NodeType.Conv_I2: + case NodeType.Conv_I4: + case NodeType.Conv_I8: + case NodeType.Conv_Ovf_I: + case NodeType.Conv_Ovf_I1: + case NodeType.Conv_Ovf_I1_Un: + case NodeType.Conv_Ovf_I2: + case NodeType.Conv_Ovf_I2_Un: + case NodeType.Conv_Ovf_I4: + case NodeType.Conv_Ovf_I4_Un: + case NodeType.Conv_Ovf_I8: + case NodeType.Conv_Ovf_I8_Un: + case NodeType.Conv_Ovf_I_Un: + case NodeType.Conv_Ovf_U: + case NodeType.Conv_Ovf_U1: + case NodeType.Conv_Ovf_U1_Un: + case NodeType.Conv_Ovf_U2: + case NodeType.Conv_Ovf_U2_Un: + case NodeType.Conv_Ovf_U4: + case NodeType.Conv_Ovf_U4_Un: + case NodeType.Conv_Ovf_U8: + case NodeType.Conv_Ovf_U8_Un: + case NodeType.Conv_Ovf_U_Un: + case NodeType.Conv_R4: + case NodeType.Conv_R8: + case NodeType.Conv_R_Un: + case NodeType.Conv_U: + case NodeType.Conv_U1: + case NodeType.Conv_U2: + case NodeType.Conv_U4: + case NodeType.Conv_U8: + case NodeType.Ldftn: + case NodeType.Ldlen: + case NodeType.Ldtoken: + case NodeType.Localloc: + case NodeType.Neg: + case NodeType.Not: + case NodeType.Refanytype: + case NodeType.Sizeof: + this.VisitUnaryExpression((UnaryExpression)node); return; + + default: + // handle type extensions with new NodeType's, that are emitted as ordinary structs and classes + Class cl = node as Class; + if (cl != null) + { + this.VisitClass(cl); return; + } + Struct st = node as Struct; + if (st != null) + { + this.VisitStruct(st); return; + } + Debug.Assert(false, "invalid node: " + node.NodeType.ToString()); + return; + } + } + void VisitAddressDereference(AddressDereference/*!*/ adr) + { + this.Visit(adr.Address); + if (adr.Alignment > 0) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x12); + this.methodBodyHeap.Write((byte)adr.Alignment); + } + if (adr.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + switch (adr.Type.typeCode) + { + case ElementType.Int8: this.methodBodyHeap.Write((byte)0x46); return; + case ElementType.UInt8: this.methodBodyHeap.Write((byte)0x47); return; + case ElementType.Int16: this.methodBodyHeap.Write((byte)0x48); return; + case ElementType.Char: + case ElementType.UInt16: this.methodBodyHeap.Write((byte)0x49); return; + case ElementType.Int32: this.methodBodyHeap.Write((byte)0x4a); return; + case ElementType.UInt32: this.methodBodyHeap.Write((byte)0x4b); return; + case ElementType.Int64: + case ElementType.UInt64: this.methodBodyHeap.Write((byte)0x4c); return; + //case ElementType.UIntPtr: + //case ElementType.IntPtr: this.methodBodyHeap.Write((byte)0x4d); return; + case ElementType.Single: this.methodBodyHeap.Write((byte)0x4e); return; + case ElementType.Double: this.methodBodyHeap.Write((byte)0x4f); return; + default: + if (adr.Type.IsValueType || (adr.Type is ITypeParameter && this.UseGenerics)) + { + this.methodBodyHeap.Write((byte)0x71); + this.methodBodyHeap.Write((int)this.GetTypeToken(adr.Type)); + return; + } + else if (TypeNode.StripModifiers(adr.Type) is Pointer) + { + this.methodBodyHeap.Write((byte)0x4d); return; + } + this.methodBodyHeap.Write((byte)0x50); + return; + } + } + void VisitAttributeList(AttributeList attrs, Node/*!*/ node) + { + if (attrs == null) return; + int n = attrs.Count; + if (n == 0) return; + int m = n; + for (int j = 0; j < n; j++) + { + AttributeNode a = attrs[j]; + if (a == null) m--; + } + if (m == 0) return; + n = m; + int codedIndex = this.GetCustomAttributeParentCodedIndex(node); + this.customAttributeCount += n; + m = this.nodesWithCustomAttributes.Count; + this.nodesWithCustomAttributes.Add(node); + int i = 0; //after the for loop i will be position where the new node should be in sorted list + NodeList nodes = this.nodesWithCustomAttributes; + for (i = m; i > 0; i--) + { + Node other = nodes[i - 1]; + int oci = this.GetCustomAttributeParentCodedIndex(other); + if (oci < codedIndex) break; + if (UseGenerics) + { + if (oci == codedIndex) Debug.Assert(false); + } + } + if (i == m) return; //node is already where it should be + for (int j = m; j > i; j--) nodes[j] = nodes[j - 1]; //Make space at postion i + nodes[i] = node; + } + void VisitAddressOf(UnaryExpression/*!*/ expr) + { + Expression operand = expr.Operand; + if (operand == null) return; + switch (operand.NodeType) + { + case NodeType.Indexer: + Indexer indexer = (Indexer)operand; + this.Visit(indexer.Object); + if (indexer.Operands == null || indexer.Operands.Count < 1) return; + this.Visit(indexer.Operands[0]); + if (expr.NodeType == NodeType.ReadOnlyAddressOf) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x1e); + } + this.methodBodyHeap.Write((byte)0x8f); + this.methodBodyHeap.Write((int)this.GetTypeToken(indexer.ElementType)); + this.stackHeight--; + return; + case NodeType.Local: + int li = this.GetLocalVarIndex((Local)operand); + if (li < 256) + { + this.methodBodyHeap.Write((byte)0x12); + this.methodBodyHeap.Write((byte)li); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x0d); + this.methodBodyHeap.Write((ushort)li); + } + this.IncrementStackHeight(); + return; + case NodeType.MemberBinding: + MemberBinding mb = (MemberBinding)operand; + if (mb.TargetObject != null) + { + this.Visit(mb.TargetObject); + this.methodBodyHeap.Write((byte)0x7c); + } + else + { + this.methodBodyHeap.Write((byte)0x7f); + this.IncrementStackHeight(); + } + this.methodBodyHeap.Write((int)this.GetFieldToken((Field)mb.BoundMember)); + return; + case NodeType.Parameter: +#if !MinimalReader + ParameterBinding pb = operand as ParameterBinding; + if (pb != null) operand = pb.BoundParameter; +#endif + int pi = ((Parameter)operand).ArgumentListIndex; + if (pi < 256) + { + this.methodBodyHeap.Write((byte)0x0f); + this.methodBodyHeap.Write((byte)pi); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x0a); + this.methodBodyHeap.Write((ushort)pi); + } + this.IncrementStackHeight(); + return; + } + } + void VisitAssignmentStatement(AssignmentStatement/*!*/ assignment) + { + this.DefineSequencePoint(assignment); + Expression target = assignment.Target; + switch (assignment.Target.NodeType) + { + case NodeType.Local: + Local loc = (Local)target; + this.Visit(assignment.Source); + this.stackHeight--; + int li = this.GetLocalVarIndex(loc); + switch (li) + { + case 0: this.methodBodyHeap.Write((byte)0x0a); return; + case 1: this.methodBodyHeap.Write((byte)0x0b); return; + case 2: this.methodBodyHeap.Write((byte)0x0c); return; + case 3: this.methodBodyHeap.Write((byte)0x0d); return; + default: + if (li < 256) + { + this.methodBodyHeap.Write((byte)0x13); + this.methodBodyHeap.Write((byte)li); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x0e); + this.methodBodyHeap.Write((ushort)li); + } + return; + } + case NodeType.MemberBinding: + MemberBinding mb = (MemberBinding)target; + if (mb.TargetObject != null) this.Visit(mb.TargetObject); + this.Visit(assignment.Source); + if (mb.TargetObject != null) + { + if (mb.Alignment != -1) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x12); + this.methodBodyHeap.Write((byte)mb.Alignment); + } + if (mb.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + this.methodBodyHeap.Write((byte)0x7d); + } + else + { + if (mb.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + this.methodBodyHeap.Write((byte)0x80); + } + this.methodBodyHeap.Write((int)this.GetFieldToken((Field)mb.BoundMember)); + if (mb.TargetObject != null) + this.stackHeight -= 2; + else + this.stackHeight--; + return; + case NodeType.Parameter: +#if !MinimalReader + ParameterBinding pb = target as ParameterBinding; + if (pb != null) target = pb.BoundParameter; +#endif + Parameter par = (Parameter)target; + this.Visit(assignment.Source); + int pi = par.ArgumentListIndex; + if (pi < 256) + { + this.methodBodyHeap.Write((byte)0x10); + this.methodBodyHeap.Write((byte)pi); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x0b); + this.methodBodyHeap.Write((ushort)pi); + } + this.stackHeight--; + return; + case NodeType.Indexer: + Indexer indexer = (Indexer)target; + this.Visit(indexer.Object); + if (indexer.Operands == null || indexer.Operands.Count < 1) return; + this.Visit(indexer.Operands[0]); + this.Visit(assignment.Source); + byte opCode; + switch (indexer.ElementType.typeCode) + { + case ElementType.UIntPtr: + case ElementType.IntPtr: opCode = 0x9b; break; + case ElementType.Boolean: + case ElementType.Int8: + case ElementType.UInt8: opCode = 0x9c; break; + case ElementType.Char: + case ElementType.Int16: + case ElementType.UInt16: opCode = 0x9d; break; + case ElementType.Int32: + case ElementType.UInt32: opCode = 0x9e; break; + case ElementType.Int64: + case ElementType.UInt64: opCode = 0x9f; break; + case ElementType.Single: opCode = 0xa0; break; + case ElementType.Double: opCode = 0xa1; break; + default: + if (this.UseGenerics && (indexer.ElementType is ITypeParameter)) + opCode = 0xa4; + else if (TypeNode.StripModifiers(indexer.ElementType) is Pointer) + opCode = 0x9b; + else + opCode = 0xa2; + break; + } + this.methodBodyHeap.Write((byte)opCode); + if (opCode == 0xa4) this.methodBodyHeap.Write((int)this.GetTypeToken(indexer.ElementType)); + this.stackHeight -= 3; + return; + case NodeType.AddressDereference: + AddressDereference adr = (AddressDereference)target; + this.Visit(adr.Address); + if (adr.Type.IsValueType || adr.Type is ITypeParameter) + { + Literal lit = assignment.Source as Literal; + if (lit != null && lit.Value == null) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x15); + this.methodBodyHeap.Write((int)this.GetTypeToken(adr.Type)); + this.stackHeight--; + return; + } + } + this.Visit(assignment.Source); + this.stackHeight -= 2; + if (adr.Alignment > 0) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x12); + this.methodBodyHeap.Write((byte)adr.Alignment); + } + if (adr.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + TypeNode adrType = TypeNode.StripModifiers(adr.Type); + if (adrType == null) return; + switch (adrType.typeCode) + { + case ElementType.Int8: + case ElementType.UInt8: this.methodBodyHeap.Write((byte)0x52); return; + case ElementType.Int16: + case ElementType.UInt16: this.methodBodyHeap.Write((byte)0x53); return; + case ElementType.Int32: + case ElementType.UInt32: this.methodBodyHeap.Write((byte)0x54); return; + case ElementType.Int64: + case ElementType.UInt64: this.methodBodyHeap.Write((byte)0x55); return; + case ElementType.Single: this.methodBodyHeap.Write((byte)0x56); return; + case ElementType.Double: this.methodBodyHeap.Write((byte)0x57); return; + case ElementType.UIntPtr: + case ElementType.IntPtr: this.methodBodyHeap.Write((byte)0xdf); return; + default: + if (adrType != null && (adrType.IsValueType || + this.UseGenerics && (adrType is ITypeParameter))) + { + this.methodBodyHeap.Write((byte)0x81); + this.methodBodyHeap.Write((int)this.GetTypeToken(adrType)); + return; + } + if (adrType.NodeType == NodeType.Pointer) + { + this.methodBodyHeap.Write((byte)0xdf); return; + } + this.methodBodyHeap.Write((byte)0x51); + return; + } + default: + Debug.Assert(false, "unexpected assignment target"); + return; + } + } +#if !MinimalReader + void VisitBase(Base/*!*/ Base) + { + this.IncrementStackHeight(); + this.methodBodyHeap.Write((byte)0x02); + } +#endif + void VisitBinaryExpression(BinaryExpression/*!*/ binaryExpression) + { + byte opCode = 0; + this.Visit(binaryExpression.Operand1); + switch (binaryExpression.NodeType) + { + case NodeType.Castclass: opCode = 0x74; goto writeOpCodeAndToken; + case NodeType.Isinst: opCode = 0x75; goto writeOpCodeAndToken; + case NodeType.Unbox: opCode = 0x79; goto writeOpCodeAndToken; + case NodeType.UnboxAny: opCode = 0xa5; goto writeOpCodeAndToken; + case NodeType.Box: opCode = 0x8c; goto writeOpCodeAndToken; + case NodeType.Refanyval: opCode = 0xc2; goto writeOpCodeAndToken; + case NodeType.Mkrefany: opCode = 0xc6; goto writeOpCodeAndToken; + writeOpCodeAndToken: + this.methodBodyHeap.Write((byte)opCode); + Literal lit = binaryExpression.Operand2 as Literal; + if (lit != null) + this.methodBodyHeap.Write((int)this.GetTypeToken((TypeNode)lit.Value)); + else + { + // TODO: Normalized IR should never use a MemberBinding to represent a type + this.methodBodyHeap.Write((int)this.GetTypeToken((TypeNode)((MemberBinding)binaryExpression.Operand2).BoundMember)); + } + return; + case NodeType.Ldvirtftn: opCode = 0x07; this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)opCode); + this.methodBodyHeap.Write((int)this.GetMethodToken((Method)((MemberBinding)binaryExpression.Operand2).BoundMember)); + return; + } + this.Visit(binaryExpression.Operand2); + switch (binaryExpression.NodeType) + { + case NodeType.Add: opCode = 0x58; break; + case NodeType.Sub: opCode = 0x59; break; + case NodeType.Mul: opCode = 0x5a; break; + case NodeType.Div: opCode = 0x5b; break; + case NodeType.Div_Un: opCode = 0x5c; break; + case NodeType.Rem: opCode = 0x5d; break; + case NodeType.Rem_Un: opCode = 0x5e; break; + case NodeType.And: opCode = 0x5f; break; + case NodeType.Or: opCode = 0x60; break; + case NodeType.Xor: opCode = 0x61; break; + case NodeType.Shl: opCode = 0x62; break; + case NodeType.Shr: opCode = 0x63; break; + case NodeType.Shr_Un: opCode = 0x64; break; + case NodeType.Add_Ovf: opCode = 0xd6; break; + case NodeType.Add_Ovf_Un: opCode = 0xd7; break; + case NodeType.Mul_Ovf: opCode = 0xd8; break; + case NodeType.Mul_Ovf_Un: opCode = 0xd9; break; + case NodeType.Sub_Ovf: opCode = 0xda; break; + case NodeType.Sub_Ovf_Un: opCode = 0xdb; break; + case NodeType.Ceq: opCode = 0x01; this.methodBodyHeap.Write((byte)0xfe); break; + case NodeType.Cgt: opCode = 0x02; this.methodBodyHeap.Write((byte)0xfe); break; + case NodeType.Cgt_Un: opCode = 0x03; this.methodBodyHeap.Write((byte)0xfe); break; + case NodeType.Clt: opCode = 0x04; this.methodBodyHeap.Write((byte)0xfe); break; + case NodeType.Clt_Un: opCode = 0x05; this.methodBodyHeap.Write((byte)0xfe); break; + } + this.methodBodyHeap.Write((byte)opCode); + this.stackHeight--; + } + void VisitBlock(Block/*!*/ block) + { + MethodInfo mInfo = this.methodInfo; + int currentAddress = (int)this.methodBodyHeap.BaseStream.Position; + this.VisitFixupList((Fixup)this.methodInfo.fixupIndex[block.UniqueKey], currentAddress); + mInfo.fixupIndex[block.UniqueKey] = currentAddress; + this.methodBodyHeap.BaseStream.Position = currentAddress; + int savedStackHeight = this.stackHeight; + if (this.exceptionBlock[block.UniqueKey] != null) this.stackHeight = 1; + StatementList statements = block.Statements; + if (statements == null) return; +#if !ROTOR + if (this.symWriter != null && block.HasLocals) + { + LocalList savedDebugLocals = mInfo.debugLocals; + Int32List savedSignatureLengths = mInfo.signatureLengths; + Int32List savedSignatureOffsets = mInfo.signatureOffsets; + mInfo.debugLocals = new LocalList(); + mInfo.signatureLengths = new Int32List(); + mInfo.signatureOffsets = new Int32List(); + this.symWriter.OpenScope((uint)currentAddress); + for (int i = 0, n = statements.Count; i < n; i++) + this.Visit(statements[i]); + if (this.stackHeight > 0) this.stackHeightExitTotal += this.stackHeight; + this.DefineLocalVariables(currentAddress, mInfo.debugLocals); + mInfo.debugLocals = savedDebugLocals; + mInfo.signatureLengths = savedSignatureLengths; + mInfo.signatureOffsets = savedSignatureOffsets; + } + else + { +#endif + for (int i = 0, n = statements.Count; i < n; i++) + this.Visit(statements[i]); + if (this.stackHeight > savedStackHeight) this.stackHeightExitTotal += (this.stackHeight - savedStackHeight); +#if !ROTOR + } +#endif + this.stackHeight = savedStackHeight; + } +#if !MinimalReader + void VisitBlockExpression(BlockExpression/*!*/ blockExpression) + { + if (blockExpression.Block == null) return; + this.VisitBlock(blockExpression.Block); + } +#endif + void VisitBranch(Branch/*!*/ branch) + { + this.DefineSequencePoint(branch); + BinaryExpression bex = branch.Condition as BinaryExpression; + UnaryExpression uex = null; + NodeType typeOfCondition = NodeType.Nop; + if (bex != null) + { + switch (bex.NodeType) + { + case NodeType.Eq: + case NodeType.Ge: + case NodeType.Gt: + case NodeType.Le: + case NodeType.Lt: + case NodeType.Ne: + this.Visit(bex.Operand1); + this.Visit(bex.Operand2); + typeOfCondition = bex.NodeType; + this.stackHeight -= 2; + break; + case NodeType.And: + case NodeType.Or: + case NodeType.Xor: + case NodeType.Isinst: + case NodeType.Castclass: + typeOfCondition = bex.NodeType; + goto default; + default: + this.Visit(branch.Condition); + this.stackHeight--; + break; + } + } + else + { + uex = branch.Condition as UnaryExpression; + if (uex != null && uex.NodeType == NodeType.LogicalNot) + { + this.Visit(uex.Operand); + typeOfCondition = NodeType.LogicalNot; + this.stackHeight--; + } + else if (branch.Condition != null) + { + // Undefined is used here simply as a sentinel value + typeOfCondition = NodeType.Undefined; + this.Visit(branch.Condition); + this.stackHeight--; + } + } + int target = this.GetOffset(branch.Target, ref branch.shortOffset); + if (branch.ShortOffset) + { + switch (typeOfCondition) + { + case NodeType.Nop: + if (branch.Condition == null) + { + if (branch.LeavesExceptionBlock) + this.methodBodyHeap.Write((byte)0xde); + else + this.methodBodyHeap.Write((byte)0x2b); + break; + } + else + { + this.methodBodyHeap.Write((byte)0x2d); break; + } + case NodeType.And: + case NodeType.Or: + case NodeType.Xor: + case NodeType.Isinst: + case NodeType.Castclass: + case NodeType.Undefined: + this.methodBodyHeap.Write((byte)0x2d); break; + case NodeType.LogicalNot: + this.methodBodyHeap.Write((byte)0x2c); break; + case NodeType.Eq: + this.methodBodyHeap.Write((byte)0x2e); break; + case NodeType.Ge: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x34); + else + this.methodBodyHeap.Write((byte)0x2f); + break; + case NodeType.Gt: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x35); + else + this.methodBodyHeap.Write((byte)0x30); + break; + case NodeType.Le: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x36); + else + this.methodBodyHeap.Write((byte)0x31); + break; + case NodeType.Lt: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x37); + else + this.methodBodyHeap.Write((byte)0x32); + break; + case NodeType.Ne: + this.methodBodyHeap.Write((byte)0x33); + break; + } + this.methodBodyHeap.Write((sbyte)target); + } + else + { + switch (typeOfCondition) + { + case NodeType.Nop: + if (branch.Condition == null) + { + if (branch.LeavesExceptionBlock) + this.methodBodyHeap.Write((byte)0xdd); + else + this.methodBodyHeap.Write((byte)0x38); + break; + } + else + { + this.methodBodyHeap.Write((byte)0x3a); break; + } + case NodeType.And: + case NodeType.Or: + case NodeType.Xor: + case NodeType.Isinst: + case NodeType.Castclass: + case NodeType.Undefined: + this.methodBodyHeap.Write((byte)0x3a); break; + case NodeType.LogicalNot: + this.methodBodyHeap.Write((byte)0x39); break; + case NodeType.Eq: + this.methodBodyHeap.Write((byte)0x3b); break; + case NodeType.Ge: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x41); + else + this.methodBodyHeap.Write((byte)0x3c); + break; + case NodeType.Gt: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x42); + else + this.methodBodyHeap.Write((byte)0x3d); + break; + case NodeType.Le: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x43); + else + this.methodBodyHeap.Write((byte)0x3e); + break; + case NodeType.Lt: + if (branch.BranchIfUnordered) + this.methodBodyHeap.Write((byte)0x44); + else + this.methodBodyHeap.Write((byte)0x3f); + break; + case NodeType.Ne: + this.methodBodyHeap.Write((byte)0x40); break; + } + this.methodBodyHeap.Write((int)target); + } + } + void VisitMethodCall(MethodCall/*!*/ call) + { + MemberBinding mb = (MemberBinding)call.Callee; + TypeNode constraint = call.Constraint; + this.Visit(mb.TargetObject); + ExpressionList arguments = call.Operands; + int pops = 0; + if (arguments != null) + { + this.VisitExpressionList(arguments); + pops = arguments.Count; + } + if (call.Type != CoreSystemTypes.Void) { this.VisitReferencedType(call.Type); pops--; } + if (pops >= 0) + this.stackHeight -= pops; + else + this.IncrementStackHeight(); //make sure the high water mark moves up if necessary + if (call.IsTailCall) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x14); + } + else if (constraint != null) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x16); + this.methodBodyHeap.Write((int)this.GetTypeToken(constraint)); + } + switch (call.NodeType) + { + case NodeType.Calli: + this.methodBodyHeap.Write((byte)0x29); + BinaryWriter sig = new BinaryWriter(new MemoryStream()); + this.WriteMethodSignature(sig, (FunctionPointer)mb.BoundMember); + this.methodBodyHeap.Write((int)(0x11000000 | this.GetStandAloneSignatureIndex(sig))); + return; + case NodeType.Callvirt: this.methodBodyHeap.Write((byte)0x6f); break; + case NodeType.Jmp: this.methodBodyHeap.Write((byte)0x27); break; + default: this.methodBodyHeap.Write((byte)0x28); break; + } + Method method = (Method)mb.BoundMember; + if ((method.CallingConvention & (CallingConventionFlags)7) == CallingConventionFlags.VarArg || + (method.CallingConvention & (CallingConventionFlags)7) == CallingConventionFlags.C) + { + this.methodBodyHeap.Write((int)this.GetMemberRefToken(method, arguments)); + } + else + this.methodBodyHeap.Write((int)this.GetMethodToken(method)); + } + void VisitClass(Class/*!*/ Class) + { + if (this.UseGenerics && Class.Template != null && Class.Template.IsGeneric) return; + this.VisitAttributeList(Class.Attributes, Class); + this.VisitSecurityAttributeList(Class.SecurityAttributes, Class); + if (Class.BaseClass != null) this.VisitReferencedType(Class.BaseClass); + for (int i = 0, n = Class.Interfaces == null ? 0 : Class.Interfaces.Count; i < n; i++) + { + this.GetTypeDefOrRefOrSpecEncoded(Class.Interfaces[i]); + if (Class.Interfaces[i] != null) this.interfaceEntries.Add(Class); + } + if (Class.NodeType == NodeType.ClassParameter && !(Class is MethodClassParameter)) + this.interfaceEntries.Add(Class); + for (int i = 0, n = Class.Members.Count; i < n; i++) + { + Member mem = Class.Members[i]; + if (mem == null || mem is TypeNode) continue; + this.Visit(mem); + } + if ((Class.Flags & (TypeFlags.ExplicitLayout | TypeFlags.SequentialLayout)) != 0 && (Class.PackingSize != 0 || Class.ClassSize != 0)) + this.classLayoutEntries.Add(Class); + } + void VisitConstruct(Construct/*!*/ cons) + { + int pops = -1; + ExpressionList operands = cons.Operands; + if (operands != null) + { + this.VisitExpressionList(cons.Operands); + pops = operands.Count - 1; + } + if (pops >= 0) + this.stackHeight -= pops; + else + this.IncrementStackHeight(); + this.methodBodyHeap.Write((byte)0x73); + Method method = ((MemberBinding)cons.Constructor).BoundMember as Method; + if (method == null) return; + this.methodBodyHeap.Write((int)this.GetMethodToken(method)); //REVIEW: varargs? + } + void VisitConstructArray(ConstructArray/*!*/ consArr) + { + if (consArr == null || consArr.Operands == null || consArr.Operands.Count < 1) return; + this.Visit(consArr.Operands[0]); + this.methodBodyHeap.Write((byte)0x8d); + this.methodBodyHeap.Write((int)this.GetTypeToken(consArr.ElementType)); + } + void VisitDelegateNode(DelegateNode/*!*/ delegateNode) + { + if (this.UseGenerics && delegateNode.Template != null && delegateNode.Template.IsGeneric) return; + this.VisitAttributeList(delegateNode.Attributes, delegateNode); + this.VisitSecurityAttributeList(delegateNode.SecurityAttributes, delegateNode); + this.VisitReferencedType(CoreSystemTypes.MulticastDelegate); + for (int i = 0, n = delegateNode.Interfaces == null ? 0 : delegateNode.Interfaces.Count; i < n; i++) + { //REVIEW: is this valid? + this.GetTypeDefOrRefOrSpecEncoded(delegateNode.Interfaces[i]); + if (delegateNode.Interfaces[i] != null) this.interfaceEntries.Add(delegateNode); + } + for (int i = 0, n = delegateNode.Members.Count; i < n; i++) + { + Member mem = delegateNode.Members[i]; + if (mem == null || mem is TypeNode) continue; + this.Visit(mem); + } + } + void VisitEndFilter(EndFilter/*!*/ endFilter) + { + this.DefineSequencePoint(endFilter); + this.Visit(endFilter.Value); + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x11); + this.stackHeight--; + } + void VisitEnumNode(EnumNode/*!*/ enumNode) + { + this.VisitAttributeList(enumNode.Attributes, enumNode); + this.VisitSecurityAttributeList(enumNode.SecurityAttributes, enumNode); + this.VisitReferencedType(CoreSystemTypes.Enum); + for (int i = 0, n = enumNode.Interfaces == null ? 0 : enumNode.Interfaces.Count; i < n; i++) + { + this.GetTypeDefOrRefOrSpecEncoded(enumNode.Interfaces[i]); + if (enumNode.Interfaces[i] != null) this.interfaceEntries.Add(enumNode); + } + for (int i = 0, n = enumNode.Members.Count; i < n; i++) + this.Visit(enumNode.Members[i]); + } + void VisitEvent(Event/*!*/ Event) + { + object eindex = this.eventIndex[Event.UniqueKey]; + if (eindex != null) return; + int index = this.eventEntries.Count + 1; + this.eventEntries.Add(Event); + this.eventIndex[Event.UniqueKey] = index; + object evindex = this.eventMapIndex[Event.DeclaringType.UniqueKey]; + if (evindex == null) + { + this.eventMapEntries.Add(Event); + this.eventMapIndex[Event.DeclaringType.UniqueKey] = this.eventMapEntries.Count; + } + if (Event.HandlerAdder != null) this.methodSemanticsEntries.Add(Event); + if (Event.HandlerRemover != null) this.methodSemanticsEntries.Add(Event); + if (Event.HandlerCaller != null) this.methodSemanticsEntries.Add(Event); + if (Event.OtherMethods != null) + for (int i = 0, n = Event.OtherMethods.Count; i < n; i++) + this.methodSemanticsEntries.Add(Event); + this.VisitAttributeList(Event.Attributes, Event); + } + void VisitExpression(Expression/*!*/ expression) + { + switch (expression.NodeType) + { + case NodeType.Dup: + this.methodBodyHeap.Write((byte)0x25); + this.IncrementStackHeight(); + return; + case NodeType.Pop: + UnaryExpression unex = expression as UnaryExpression; + if (unex != null) + { + this.Visit(unex.Operand); + this.stackHeight--; + this.methodBodyHeap.Write((byte)0x26); + } + return; + case NodeType.Arglist: + this.IncrementStackHeight(); + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x00); + return; + } + } + void VisitExpressionList(ExpressionList expressions) + { + if (expressions == null) return; + for (int i = 0, n = expressions.Count; i < n; i++) + this.Visit(expressions[i]); + } + void VisitExpressionStatement(ExpressionStatement/*!*/ statement) + { +#if !MinimalReader + if (!(statement.Expression is BlockExpression)) +#endif + this.DefineSequencePoint(statement); + this.Visit(statement.Expression); + } + void VisitField(Field/*!*/ field) + { + this.VisitAttributeList(field.Attributes, field); + this.GetFieldIndex(field); + if (field.IsVolatile) + field.Type = RequiredModifier.For(CoreSystemTypes.IsVolatile, field.Type); + this.VisitReferencedType(field.Type); + } + void VisitFixupList(Fixup fixup, int targetAddress) + { + while (fixup != null) + { + this.methodBodyHeap.BaseStream.Position = fixup.fixupLocation; + if (fixup.shortOffset) + { + int offset = targetAddress - fixup.addressOfNextInstruction; + Debug.Assert(-128 <= offset && offset <= 127, "Invalid short branch"); + this.methodBodyHeap.Write((byte)offset); + } + else + this.methodBodyHeap.Write((int)(targetAddress - fixup.addressOfNextInstruction)); + fixup = fixup.nextFixUp; + } + } + void VisitGenericParameterList(Member/*!*/ member, TypeNodeList/*!*/ parameters) + { + if (member == null || parameters == null || !this.UseGenerics) return; + int sign = member is Method ? -1 : 1; + for (int i = 0, n = parameters.Count; i < n; i++) + { + TypeNode parameter = parameters[i]; + if (parameter == null) continue; + this.typeParameterNumber[parameter.UniqueKey] = sign * (i + 1); + this.genericParamEntries.Add(member); + if (((ITypeParameter)parameter).DeclaringMember != member) + parameter = (TypeNode)parameter.Clone(); + this.genericParameters.Add(parameter); + if (parameter.BaseType is Class && parameter.BaseType != CoreSystemTypes.Object) + this.genericParamConstraintEntries.Add(parameter); + for (int j = 0, m = parameter.Interfaces == null ? 0 : parameter.Interfaces.Count; j < m; j++) + this.genericParamConstraintEntries.Add(parameter); + } + } + void VisitIndexer(Indexer/*!*/ indexer) + { + this.Visit(indexer.Object); + if (indexer.Operands == null || indexer.Operands.Count < 1) return; + this.Visit(indexer.Operands[0]); + byte opCode; + switch (indexer.ElementType.typeCode) + { + case ElementType.Boolean: + case ElementType.Int8: opCode = 0x90; break; + case ElementType.UInt8: opCode = 0x91; break; + case ElementType.Int16: opCode = 0x92; break; + case ElementType.Char: + case ElementType.UInt16: opCode = 0x93; break; + case ElementType.Int32: opCode = 0x94; break; + case ElementType.UInt32: opCode = 0x95; break; + case ElementType.Int64: + case ElementType.UInt64: opCode = 0x96; break; + case ElementType.UIntPtr: + case ElementType.IntPtr: opCode = 0x97; break; + case ElementType.Single: opCode = 0x98; break; + case ElementType.Double: opCode = 0x99; break; + default: + if (this.UseGenerics && indexer.ElementType is ITypeParameter) + opCode = 0xa3; + else if (TypeNode.StripModifiers(indexer.ElementType) is Pointer) + opCode = 0x97; + else + opCode = 0x9a; + break; + } + this.methodBodyHeap.Write((byte)opCode); + if (opCode == 0xa3) this.methodBodyHeap.Write((int)this.GetTypeToken(indexer.ElementType)); + this.stackHeight--; + } + void VisitInterface(Interface/*!*/ Interface) + { + if (this.UseGenerics && Interface.Template != null && Interface.Template.IsGeneric) return; + this.VisitAttributeList(Interface.Attributes, Interface); + this.VisitSecurityAttributeList(Interface.SecurityAttributes, Interface); + InterfaceList interfaces = Interface.Interfaces; + for (int i = 0, n = interfaces == null ? 0 : interfaces.Count; i < n; i++) + { + this.GetTypeDefOrRefOrSpecEncoded(interfaces[i]); + if (interfaces[i] != null) this.interfaceEntries.Add(Interface); + } + if (Interface.NodeType == NodeType.TypeParameter && !(Interface is MethodTypeParameter)) + this.interfaceEntries.Add(Interface); + for (int i = 0, n = Interface.Members.Count; i < n; i++) + { + Member mem = Interface.Members[i]; + if (mem == null || mem is TypeNode) continue; + this.Visit(mem); + } + } + void VisitLocal(Local/*!*/ local) + { + this.IncrementStackHeight(); + int li = this.GetLocalVarIndex(local); + switch (li) + { + case 0: this.methodBodyHeap.Write((byte)0x06); return; + case 1: this.methodBodyHeap.Write((byte)0x07); return; + case 2: this.methodBodyHeap.Write((byte)0x08); return; + case 3: this.methodBodyHeap.Write((byte)0x09); return; + default: + if (li < 256) + { + this.methodBodyHeap.Write((byte)0x11); + this.methodBodyHeap.Write((byte)li); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x0c); + this.methodBodyHeap.Write((ushort)li); + } + return; + } + } +#if !MinimalReader + /// <summary> + /// This just gets the local variable index for each local declaration. + /// That associates the debug information with the right block because + /// it is the block the local is declared in rather than the subblock + /// it is first referenced in. (When different, the debugger only knows + /// about the local when control is in the subblock.) + /// </summary> + /// <param name="localDeclarations">The list of locals declared at this statement</param> + void VisitLocalDeclarationsStatement(LocalDeclarationsStatement/*!*/ localDeclarations) + { + if (localDeclarations == null) return; + LocalDeclarationList decls = localDeclarations.Declarations; + for (int i = 0, n = decls == null ? 0 : decls.Count; i < n; i++) + { + //^ assert decls != null; + LocalDeclaration decl = decls[i]; + if (decl == null) continue; + Field f = decl.Field; + if (f == null) continue; + //^ assume this.currentMethod != null; + Local loc = this.currentMethod.GetLocalForField(f); + loc.Type = localDeclarations.Type; + this.GetLocalVarIndex(loc); + } + } +#endif + void VisitLiteral(Literal/*!*/ literal) + { + this.IncrementStackHeight(); + IConvertible ic = literal.Value as IConvertible; + if (ic == null) + { + Debug.Assert(literal.Value == null && !literal.Type.IsValueType); + this.methodBodyHeap.Write((byte)0x14); return; + } + TypeCode tc = ic.GetTypeCode(); + switch (tc) + { + case TypeCode.Boolean: + case TypeCode.SByte: + case TypeCode.Byte: + case TypeCode.Char: + case TypeCode.Int16: + case TypeCode.UInt16: + case TypeCode.Int32: + case TypeCode.UInt32: + case TypeCode.Int64: + long n = ic.ToInt64(null); + switch (n) + { + case -1: this.methodBodyHeap.Write((byte)0x15); break; + case 0: this.methodBodyHeap.Write((byte)0x16); break; + case 1: this.methodBodyHeap.Write((byte)0x17); break; + case 2: this.methodBodyHeap.Write((byte)0x18); break; + case 3: this.methodBodyHeap.Write((byte)0x19); break; + case 4: this.methodBodyHeap.Write((byte)0x1a); break; + case 5: this.methodBodyHeap.Write((byte)0x1b); break; + case 6: this.methodBodyHeap.Write((byte)0x1c); break; + case 7: this.methodBodyHeap.Write((byte)0x1d); break; + case 8: this.methodBodyHeap.Write((byte)0x1e); break; + default: + if (n >= System.SByte.MinValue && n <= System.SByte.MaxValue) + { + this.methodBodyHeap.Write((byte)0x1f); + this.methodBodyHeap.Write((byte)n); + } + else if (n >= System.Int32.MinValue && n <= System.Int32.MaxValue || + n <= System.UInt32.MaxValue && (tc == TypeCode.Char || tc == TypeCode.UInt16 || tc == TypeCode.UInt32)) + { + if (n == System.UInt32.MaxValue && tc != TypeCode.Int64) + this.methodBodyHeap.Write((byte)0x15); + else + { + this.methodBodyHeap.Write((byte)0x20); + this.methodBodyHeap.Write((int)n); + } + } + else + { + this.methodBodyHeap.Write((byte)0x21); + this.methodBodyHeap.Write((long)n); + tc = TypeCode.Empty; //Suppress conversion to long + } + break; + } + if (tc == TypeCode.Int64) + this.methodBodyHeap.Write((byte)0x6a); + return; + + case TypeCode.UInt64: + this.methodBodyHeap.Write((byte)0x21); + this.methodBodyHeap.Write(ic.ToUInt64(null)); + return; + + case TypeCode.Single: + this.methodBodyHeap.Write((byte)0x22); + this.methodBodyHeap.Write(ic.ToSingle(null)); + return; + + case TypeCode.Double: + this.methodBodyHeap.Write((byte)0x23); + this.methodBodyHeap.Write(ic.ToDouble(null)); + return; + + case TypeCode.String: + this.methodBodyHeap.Write((byte)0x72); + this.methodBodyHeap.Write((int)(this.GetUserStringIndex((String)literal.Value) | 0x70000000)); + return; + } + Debug.Assert(false, "Unexpected literal type"); + } + void VisitMemberBinding(MemberBinding/*!*/ memberBinding) + { + if (memberBinding.TargetObject != null) + { + this.Visit(memberBinding.TargetObject); + if (memberBinding.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + this.methodBodyHeap.Write((byte)0x7b); + } + else + { + this.IncrementStackHeight(); + if (memberBinding.Volatile) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x13); + } + this.methodBodyHeap.Write((byte)0x7e); + } + this.methodBodyHeap.Write((int)this.GetFieldToken((Field)memberBinding.BoundMember)); + return; + } + void VisitMethod(Method/*!*/ method) + { + if (this.UseGenerics && method.Template != null && method.Template.IsGeneric) return; + this.GetMethodIndex(method); + this.VisitAttributeList(method.Attributes, method); + this.VisitSecurityAttributeList(method.SecurityAttributes, method); + for (int i = 0, n = method.Parameters == null ? 0 : method.Parameters.Count; i < n; i++) + { + Parameter par = method.Parameters[i]; + if (par == null) continue; + this.VisitAttributeList(par.Attributes, par); + this.VisitReferencedType(par.Type); + } + if (method.ReturnType != null) + this.VisitReferencedType(method.ReturnType); + if (!method.IsAbstract && method.Body != null) + { + if (method.Body.Statements != null && method.Body.Statements.Count > 0) + this.VisitMethodBody(method); + } + MethodList implementedInterfaceMethods = method.ImplementedInterfaceMethods; + for (int i = 0, n = implementedInterfaceMethods == null ? 0 : implementedInterfaceMethods.Count; i < n; i++) + { + Method im = implementedInterfaceMethods[i]; + if (im == null) continue; + this.methodImplEntries.Add(method); + } + if ((method.Flags & MethodFlags.PInvokeImpl) != 0 && method.PInvokeImportName != null && method.PInvokeModule != null) + { + this.implMapEntries.Add(method); + this.GetStringIndex(method.PInvokeImportName); + this.GetModuleRefIndex(method.PInvokeModule); + } + } + void VisitMethodBody(Method/*!*/ method) + { + //Visit body, emitting IL bytes and gathering information + this.methodBodyHeap = new BinaryWriter(new MemoryStream()); + this.methodInfo = new MethodInfo(); + this.currentMethod = method; + this.stackHeightMax = 0; + this.stackHeightExitTotal = 0; +#if !ROTOR + if (this.symWriter != null) + { + this.methodInfo.debugLocals = new LocalList(); + this.methodInfo.signatureLengths = new Int32List(); + this.methodInfo.signatureOffsets = new Int32List(); + this.methodInfo.statementNodes = new NodeList(); + this.methodInfo.statementOffsets = new Int32List(); + this.symWriter.OpenMethod((uint)this.GetMethodDefToken(method)); + this.symWriter.OpenScope(0u); +#if !MinimalReader + MethodScope scope = method.Scope; + if (scope != null) + { + UsedNamespaceList usedNamespaces = scope.UsedNamespaces; + for (int i = 0, n = usedNamespaces == null ? 0 : usedNamespaces.Count; i < n; i++) + { + //^ assert usedNamespaces != null; + UsedNamespace uns = usedNamespaces[i]; + if (uns == null || uns.Namespace == null) continue; + this.symWriter.UsingNamespace(uns.Namespace.ToString()); + } + } +#endif + } +#endif +#if !FxCop + int originalAddress = 0; + if (method.LocalList != null) + { + for (int i = 0, n = method.LocalList.Count; i < n; i++) + { + Local loc = method.LocalList[i]; + if (loc == null) continue; + this.GetLocalVarIndex(loc); + } +#if !ROTOR + if (this.symWriter != null) + { + int currentAddress = (int)this.methodBodyHeap.BaseStream.Position; + originalAddress = currentAddress; + this.symWriter.OpenScope((uint)currentAddress); + } +#endif + } +#endif + int exceptionHandlersCount = method.ExceptionHandlers == null ? 0 : method.ExceptionHandlers.Count; + if (exceptionHandlersCount > 0) + { + this.exceptionBlock = new TrivialHashtable(); + for (int i = 0; i < exceptionHandlersCount; i++) + { + ExceptionHandler eh = method.ExceptionHandlers[i]; + if (eh == null || eh.HandlerStartBlock == null || (eh.HandlerType != NodeType.Catch && eh.HandlerType != NodeType.Filter)) continue; + this.exceptionBlock[eh.HandlerStartBlock.UniqueKey] = eh; + } + } + this.VisitBlock(method.Body); + +#if !FxCop + if (method.LocalList != null) + { +#if !ROTOR + if (this.symWriter != null) + { + DefineLocalVariables(originalAddress, method.LocalList); + } +#endif + } +#endif + + this.methodBodiesHeapIndex[method.UniqueKey] = (int)this.methodBodiesHeap.BaseStream.Position; + int maxStack = this.stackHeightExitTotal + this.stackHeightMax; //Wildly pessimistic estimate. Works dandy if BBlocks never leave anything on the stack. + if (exceptionHandlersCount > 0 && maxStack == 0) maxStack = 1; + int codeSize = (int)this.methodBodyHeap.BaseStream.Position; + int localVarSigTok = this.methodInfo.localVarSigTok; + bool fatHeader = codeSize >= 64 || exceptionHandlersCount > 0 || maxStack > 8 || localVarSigTok != 0; + if (fatHeader) + { + //Emit fat header + byte header = 0x03; + if (method.InitLocals) header |= 0x10; + if (exceptionHandlersCount > 0) header |= 0x08; + this.methodBodiesHeap.Write((byte)header); + this.methodBodiesHeap.Write((byte)0x30); //top 4 bits represent length of fat header in dwords. Heaven only knows why. + this.methodBodiesHeap.Write((short)maxStack); + this.methodBodiesHeap.Write((int)codeSize); + if (localVarSigTok != 0) + { + if (this.methodInfo.localVarIndex.Count > 127) + { + //Need to make space for the two byte count + this.methodInfo.localVarSignature.Write((byte)0); + byte[] buf = this.methodInfo.localVarSignature.BaseStream.Buffer; + int n = buf.Length; + for (int i = n - 2; i > 1; i--) buf[i + 1] = buf[i]; + } + this.methodInfo.localVarSignature.BaseStream.Position = 0; + this.methodInfo.localVarSignature.Write((byte)7); + Ir2md.WriteCompressedInt(this.methodInfo.localVarSignature, this.methodInfo.localVarIndex.Count); + Debug.Assert(this.methodInfo.localVarIndex.Count <= 0xFFFE); + } + this.methodBodiesHeap.Write((int)localVarSigTok); + } + else + { + //Emit tiny header + this.methodBodiesHeap.Write((byte)(codeSize << 2 | 2)); + } + //Copy body to bodies heap + ((MemoryStream)this.methodBodyHeap.BaseStream).WriteTo(this.methodBodiesHeap.BaseStream); + int pad = (int)this.methodBodiesHeap.BaseStream.Position; + while (pad % 4 != 0) { pad++; this.methodBodiesHeap.Write((byte)0); } + if (fatHeader) + { + //Emit exception handler entries + int[] tryOffsets = new int[exceptionHandlersCount]; + int[] tryLengths = new int[exceptionHandlersCount]; + int[] handlerOffsets = new int[exceptionHandlersCount]; + int[] handlerLengths = new int[exceptionHandlersCount]; + bool fatFormat = false; + for (int i = 0; i < exceptionHandlersCount; i++) + { + ExceptionHandler eh = method.ExceptionHandlers[i]; + int tryOffset = tryOffsets[i] = (int)this.methodInfo.fixupIndex[eh.TryStartBlock.UniqueKey]; + int tryLength = tryLengths[i] = ((int)this.methodInfo.fixupIndex[eh.BlockAfterTryEnd.UniqueKey]) - tryOffset; + int handlerOffset = handlerOffsets[i] = (int)this.methodInfo.fixupIndex[eh.HandlerStartBlock.UniqueKey]; + int handlerLength = handlerLengths[i] = ((int)this.methodInfo.fixupIndex[eh.BlockAfterHandlerEnd.UniqueKey]) - handlerOffset; + if (tryOffset > 0xffff || tryLength > 0xff || handlerOffset > 0xffff || handlerLength > 0xff) fatFormat = true; + } + if (exceptionHandlersCount * 12 > 0xff) fatFormat = true; + if (fatFormat) + { + int dataSize = exceptionHandlersCount * 24 + 4; + this.methodBodiesHeap.Write((byte)0x41); + this.methodBodiesHeap.Write((byte)(dataSize & 0xff)); + this.methodBodiesHeap.Write((short)((dataSize >> 8) & 0xffff)); + } + else + { + int dataSize = exceptionHandlersCount * 12 + 4; + this.methodBodiesHeap.Write((byte)0x01); + this.methodBodiesHeap.Write((byte)dataSize); + this.methodBodiesHeap.Write((short)0); + } + for (int i = 0; i < exceptionHandlersCount; i++) + { + ExceptionHandler eh = method.ExceptionHandlers[i]; + byte flags = 0; + switch (eh.HandlerType) + { + case NodeType.Filter: flags = 0x0001; break; + case NodeType.Finally: flags = 0x0002; break; + case NodeType.FaultHandler: flags = 0x0004; break; + } + if (fatFormat) + { + this.methodBodiesHeap.Write((int)flags); + this.methodBodiesHeap.Write((int)tryOffsets[i]); + this.methodBodiesHeap.Write((int)tryLengths[i]); + this.methodBodiesHeap.Write((int)handlerOffsets[i]); + this.methodBodiesHeap.Write((int)handlerLengths[i]); + } + else + { + this.methodBodiesHeap.Write((short)flags); + this.methodBodiesHeap.Write((ushort)tryOffsets[i]); + this.methodBodiesHeap.Write((byte)tryLengths[i]); + this.methodBodiesHeap.Write((ushort)handlerOffsets[i]); + this.methodBodiesHeap.Write((byte)handlerLengths[i]); + } + if (eh.FilterType != null) + this.methodBodiesHeap.Write((int)this.GetTypeToken(eh.FilterType)); + else if (eh.FilterExpression != null) + this.methodBodiesHeap.Write((int)this.methodInfo.fixupIndex[eh.FilterExpression.UniqueKey]); + else + this.methodBodiesHeap.Write((int)0); + } + } +#if !ROTOR + if (this.symWriter != null) + { + MethodInfo mInfo = this.methodInfo; + NodeList statementNodes = mInfo.statementNodes; + Int32List statementOffsets = mInfo.statementOffsets; + int n = statementNodes.Count; + int j = 0; + int k = 0; + Document d = null; + ISymUnmanagedDocumentWriter doc = null; + for (int i = 0; i < n; i++) + { + Document e = statementNodes[i].SourceContext.Document; + if (e == null) continue; + if (e != d) + { + d = e; + if (doc != null) this.DefineSequencePoints(statementNodes, statementOffsets, j, k, doc); + doc = this.GetDocumentWriter(d); + j = i; + k = 0; + } + k++; + } + this.DefineSequencePoints(statementNodes, statementOffsets, j, k, doc); + this.symWriter.CloseScope((uint)this.methodBodyHeap.BaseStream.Position); + this.symWriter.CloseMethod(); + } +#endif + //this.methodBodyHeap = null; + //this.methodInfo = null; + //this.currentMethod = null; + } + +#if !ROTOR + private void DefineLocalVariables(int startAddress, LocalList locals) + { + MethodInfo mInfo = this.methodInfo; + for (int i = 0, n = locals.Count; i < n; i++) + { + Local loc = locals[i]; + string name = loc.Name.ToString(); + unsafe + { + fixed (byte* p = mInfo.localVarSignature.BaseStream.Buffer) + { + IntPtr sp = (IntPtr)(p + mInfo.signatureOffsets[i]); + uint c = (uint)mInfo.signatureLengths[i]; + this.symWriter.DefineLocalVariable(name, 0u, c, sp, 1u, (uint)this.GetLocalVarIndex(loc), 0u, 0u, 0u); + } + } + } + int posOfFirstInstructionOfNextBlock = this.methodBodyHeap.BaseStream.Position; + if (posOfFirstInstructionOfNextBlock > startAddress) + this.symWriter.CloseScope((uint)(posOfFirstInstructionOfNextBlock - 1)); + else + this.symWriter.CloseScope((uint)startAddress); + } +#endif + void DefineSequencePoint(Node node) + { +#if !ROTOR + if (this.symWriter != null && node != null && node.SourceContext.Document != null && !node.SourceContext.Document.Hidden) + { + this.methodInfo.statementNodes.Add(node); + this.methodInfo.statementOffsets.Add(this.methodBodyHeap.BaseStream.Position); + } +#endif + } +#if !ROTOR + void DefineSequencePoints(NodeList/*!*/ statementNodes, Int32List/*!*/ statementOffsets, int start, int count, ISymUnmanagedDocumentWriter doc) + //^ requires this.symWriter != null; + { + if (count == 0) return; + uint[] offsets = new uint[count]; + uint[] lines = new uint[count]; + uint[] columns = new uint[count]; + uint[] endLines = new uint[count]; + uint[] endColumns = new uint[count]; + for (int i = 0; i < count; i++) + { + Node n = statementNodes[i + start]; + offsets[i] = i + start == 0 ? 0 : (uint)statementOffsets[i + start]; + lines[i] = (uint)n.SourceContext.StartLine; + columns[i] = (uint)n.SourceContext.StartColumn; + endLines[i] = (uint)n.SourceContext.EndLine; + endColumns[i] = (uint)n.SourceContext.EndColumn; + } + this.symWriter.DefineSequencePoints(doc, (uint)count, offsets, lines, columns, endLines, endColumns); + } +#endif + void VisitModule(Module/*!*/ module) + { + //REVIEW: check that module has no explicit lists of assembly/module references? + this.ForceTemplateTypeMethodBodiesToGetSpecialized(module); + this.VisitAttributeList(module.Attributes, module); + if (this.assembly != null) + { + Module m = new Module(); + m.Attributes = this.assembly.ModuleAttributes; + this.VisitAttributeList(m.Attributes, m); + this.VisitSecurityAttributeList(this.assembly.SecurityAttributes, this.assembly); + } + TypeNodeList allTypes = module.Types.Clone(); + for (int k = 0; k < allTypes.Count; ) + { + int typeCount = module.Types.Count; + for (int i = k, n = k, m = allTypes.Count; i < (n = allTypes.Count); ) + { + for (; i < n; i++) + { + TypeNode t = allTypes[i]; + if (t == null) continue; + if (this.UseGenerics && t.Template != null && t.Template.IsGeneric) + { + allTypes[i] = null; + continue; + } + this.GetTypeDefIndex(t); + if (i >= m) this.nestedClassEntries.Add(t); + MemberList members = t.Members; + if (members != null) + { + for (int j = 0, numMembers = members.Count; j < numMembers; j++) + { + TypeNode nt = members[j] as TypeNode; + if (nt != null) allTypes.Add(nt); + } + } + } + } + for (int i = k, n = allTypes.Count; i < n; i++) + { + TypeNode t = allTypes[i]; + if (t == null) continue; + if (this.UseGenerics && t.Template != null && t.Template.IsGeneric) + { + allTypes[i] = null; + continue; + } + MemberList mems = t.Members; + if (t is EnumNode) + { //Work around JIT bug in Beta2 + for (int jj = 0, mm = mems.Count; jj < mm; jj++) + { + Field f = mems[jj] as Field; + if (f == null || f.IsStatic) continue; + mems[jj] = mems[0]; + mems[0] = f; + break; + } + } + for (int j = 0, m = mems.Count; j < m; j++) + { + Member mem = mems[j]; + if (mem == null) continue; + switch (mem.NodeType) + { + case NodeType.Field: this.GetFieldIndex((Field)mem); break; + case NodeType.Method: + case NodeType.InstanceInitializer: + case NodeType.StaticInitializer: + Method meth = (Method)mem; + if (this.UseGenerics && meth.Template != null && meth.Template.IsGeneric) + this.GetMethodSpecIndex(meth); + else + this.GetMethodIndex(meth); + break; + } + } + } + for (int i = k, n = allTypes.Count; i < n; i++, k++) + { + TypeNode t = allTypes[i]; + if (t == null) continue; + this.Visit(t); + } + for (int i = typeCount, n = module.Types.Count; i < n; i++) + { + TypeNode t = module.Types[i]; + if (t == null) continue; + Debug.Assert(t.IsNotFullySpecialized); + //allTypes.Add(t); + } + } + } + sealed class MethodSpecializer : StandardVisitor + { + private Module/*!*/ module; + + internal MethodSpecializer(Module/*!*/ module) + { + this.module = module; + //^ base(); + } + + public override Method VisitMethod(Method method) + { + if (method == null) return null; + if (method.Template == null || method.Template.IsGeneric) return method; + TypeNodeList templateParameters = null; + TypeNodeList templateArguments = null; + if (method.TemplateArguments != null && method.TemplateArguments.Count > 0) + { + templateParameters = method.Template.TemplateParameters; + templateArguments = method.TemplateArguments; + } + else + { + TypeNode tdt = method.Template.DeclaringType; + TypeNode dt = method.DeclaringType; + templateParameters = tdt.ConsolidatedTemplateParameters; + templateArguments = dt.ConsolidatedTemplateArguments; + if (templateArguments == null) templateArguments = templateParameters; + } + if (templateParameters == null || templateParameters.Count == 0) return method; + TypeNode declaringTemplate = method.DeclaringType == null ? null : method.DeclaringType.Template; + bool savedNewTemplateInstanceIsRecursive = false; + if (declaringTemplate != null) + { + savedNewTemplateInstanceIsRecursive = declaringTemplate.NewTemplateInstanceIsRecursive; + declaringTemplate.NewTemplateInstanceIsRecursive = method.DeclaringType.IsNotFullySpecialized; + } + Duplicator duplicator = new Duplicator(this.module, method.DeclaringType); +#if !MinimalReader + TypeNode closureClone = null; + if (method.Template.Scope != null && method.Template.Scope.CapturedForClosure) + { + duplicator.TypesToBeDuplicated[method.Template.Scope.ClosureClass.UniqueKey] = method.Template.Scope.ClosureClass; + duplicator.RecordOriginalAsTemplate = true; + closureClone = duplicator.VisitTypeNode(method.Template.Scope.ClosureClass); + } +#endif + int n = method.Parameters == null ? 0 : method.Parameters.Count; + int m = method.Template.Parameters == null ? 0 : method.Template.Parameters.Count; + if (n != m) { Debug.Assert(false); if (n > m) n = m; } + for (int i = 0; i < n; i++) + { + Parameter par = method.Parameters[i]; + Parameter tpar = method.Template.Parameters[i]; + if (par == null || tpar == null) continue; + duplicator.DuplicateFor[tpar.UniqueKey] = par; + } + n = method.TemplateParameters == null ? 0 : method.TemplateParameters.Count; + m = method.Template.TemplateParameters == null ? 0 : method.Template.TemplateParameters.Count; + if (n != m && n > 0) { Debug.Assert(false); if (n > m) n = m; } + for (int i = 0; i < n; i++) + { + TypeNode tpar = method.TemplateParameters[i]; + TypeNode ttpar = method.Template.TemplateParameters[i]; + if (tpar == null || ttpar == null) continue; + duplicator.DuplicateFor[ttpar.UniqueKey] = tpar; + } + Method dup = duplicator.VisitMethod(method.Template); + //^ assume dup != null; + Specializer specializer = new Specializer(this.module, templateParameters, templateArguments); + specializer.VisitMethod(dup); +#if !MinimalReader + if (closureClone != null) + { + specializer.VisitTypeNode(closureClone); + if (method.TemplateArguments != null && method.TemplateArguments.Count > 0) + closureClone.Name = Identifier.For(closureClone.Name.ToString() + closureClone.UniqueKey); + MemberList dtMembers = method.DeclaringType.Members; + for (int i = 0, nmems = dtMembers == null ? 0 : dtMembers.Count; i < nmems; i++) + { + ClosureClass closureRef = dtMembers[i] as ClosureClass; + if (closureRef != null && closureRef.Name.UniqueIdKey == closureClone.Name.UniqueIdKey) + { + //This happens when the declaring type was instantiated after Normalizer has already injected a closure into the template + dtMembers[i] = closureClone; + closureClone = null; + break; + } + } + if (closureClone != null) + method.DeclaringType.Members.Add(closureClone); + } +#endif + if (method.Template.DeclaringType.DeclaringModule != this.module) + { + //Dealing with imported IR that misses important type information if it contains explicit stack operations (push, pop, dup) + //Call a helper visitor to remove these stack operations and in the process supply the missing type information. + Unstacker unstacker = new Unstacker(); + unstacker.Visit(dup); + } + MethodBodySpecializer mbSpecializer = this.module.GetMethodBodySpecializer(templateParameters, templateArguments); + mbSpecializer.methodBeingSpecialized = method; + mbSpecializer.dummyMethod = dup; + mbSpecializer.VisitMethod(dup); + method.Body = dup.Body; + // HACK to try to fix parameter declaring method back to the way it was before: + method.Parameters = method.Parameters; + method.ExceptionHandlers = dup.ExceptionHandlers; + if (declaringTemplate != null) + declaringTemplate.NewTemplateInstanceIsRecursive = savedNewTemplateInstanceIsRecursive; + return method; + } + } + void ForceTemplateTypeMethodBodiesToGetSpecialized(Module/*!*/ module) + { + MethodSpecializer visitor = new MethodSpecializer(module); + if (module == null) return; + TypeNodeList types = module.Types; + if (types == null) return; + for (int i = 0; i < types.Count; i++) + this.ForceTemplateTypeMethodBodiesToGetSpecialized(types[i], visitor); + } + void ForceTemplateTypeMethodBodiesToGetSpecialized(TypeNode/*!*/ type, MethodSpecializer/*!*/ visitor) + { + if (type == null) return; + if (type.IsNotFullySpecialized || type.IsGeneric) return; + bool savedNewTemplateInstanceIsRecursive = type.NewTemplateInstanceIsRecursive; + type.NewTemplateInstanceIsRecursive = type.IsNotFullySpecialized; + MemberList members = type.Members; + if (members == null) return; + for (int j = 0; j < members.Count; j++) + { + Member mem = members[j]; + if (mem == null) continue; + TypeNode t = mem as TypeNode; + if (t != null) + this.ForceTemplateTypeMethodBodiesToGetSpecialized(t, visitor); + else + visitor.VisitMethod(mem as Method); + } + type.NewTemplateInstanceIsRecursive = savedNewTemplateInstanceIsRecursive; + } + void VisitParameter(Parameter/*!*/ parameter) + { + this.IncrementStackHeight(); +#if !MinimalReader + ParameterBinding pb = parameter as ParameterBinding; + if (pb != null) parameter = pb.BoundParameter; +#endif + int pi = parameter.ArgumentListIndex; + switch (pi) + { + case 0: this.methodBodyHeap.Write((byte)0x02); return; + case 1: this.methodBodyHeap.Write((byte)0x03); return; + case 2: this.methodBodyHeap.Write((byte)0x04); return; + case 3: this.methodBodyHeap.Write((byte)0x05); return; + default: + if (pi < 256) + { + this.methodBodyHeap.Write((byte)0x0e); + this.methodBodyHeap.Write((byte)pi); + } + else + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x09); + this.methodBodyHeap.Write((ushort)pi); + } + return; + } + } + void VisitProperty(Property/*!*/ property) + { + object pindex = this.propertyIndex[property.UniqueKey]; + if (pindex != null) return; + int index = this.propertyEntries.Count + 1; + this.propertyEntries.Add(property); + this.propertyIndex[property.UniqueKey] = index; + object pmindex = this.propertyMapIndex[property.DeclaringType.UniqueKey]; + if (pmindex == null) + { + this.propertyMapEntries.Add(property); + this.propertyMapIndex[property.DeclaringType.UniqueKey] = this.propertyMapEntries.Count; + } + if (property.Getter != null) this.methodSemanticsEntries.Add(property); + if (property.Setter != null) this.methodSemanticsEntries.Add(property); + if (property.OtherMethods != null) + for (int i = 0, n = property.OtherMethods.Count; i < n; i++) + this.methodSemanticsEntries.Add(property); + this.VisitAttributeList(property.Attributes, property); + } + void VisitReferencedType(TypeNode type) + { + if (type == null) return; + if (type.IsGeneric && type.Template == null) + { + TypeNodeList templParams = type.ConsolidatedTemplateParameters; + for (int i = 0, n = templParams == null ? 0 : templParams.Count; i < n; i++) + this.typeParameterNumber[templParams[i].UniqueKey] = i + 1; + } + switch (type.typeCode) + { + case ElementType.Pointer: this.VisitReferencedType(((Pointer)type).ElementType); return; + case ElementType.Reference: this.VisitReferencedType(((Reference)type).ElementType); return; + case ElementType.Array: + case ElementType.SzArray: this.VisitReferencedType(((ArrayType)type).ElementType); return; + case ElementType.OptionalModifier: + case ElementType.RequiredModifier: + TypeModifier tm = (TypeModifier)type; + this.VisitReferencedType(tm.Modifier); + this.VisitReferencedType(tm.ModifiedType); + return; + case ElementType.FunctionPointer: + FunctionPointer fp = (FunctionPointer)type; + this.VisitReferencedType(fp.ReturnType); + for (int i = 0, n = fp.ParameterTypes == null ? 0 : fp.ParameterTypes.Count; i < n; i++) + this.VisitReferencedType(fp.ParameterTypes[i]); + return; + case ElementType.ValueType: + case ElementType.Class: + break; + default: + return; + } + if (this.IsStructural(type)) + this.GetTypeSpecIndex(type); + else if (type.DeclaringModule == this.module) + this.GetTypeDefIndex(type); + else if (type.DeclaringModule != null) + this.GetTypeRefIndex(type); + else if (type.typeCode == ElementType.ValueType || type.typeCode == ElementType.Class) + { + //Get here for type parameters + if (this.UseGenerics && this.typeParameterNumber[type.UniqueKey] != null) return; + type.DeclaringModule = this.module; + this.GetTypeDefIndex(type); + } + else + Debug.Assert(false); + } + void VisitReturn(Return/*!*/ Return) + { + this.DefineSequencePoint(Return); + if (Return.Expression != null) + { + this.Visit(Return.Expression); + this.stackHeight--; + } + this.methodBodyHeap.Write((byte)0x2a); + } + void VisitSecurityAttributeList(SecurityAttributeList attrs, Node/*!*/ node) + { + if (attrs == null) return; + int n = attrs.Count; + if (n == 0) return; + int m = n; + for (int j = 0; j < n; j++) + { + SecurityAttribute a = attrs[j]; + if (a == null) m--; + } + if (m == 0) return; + n = m; + int codedIndex = this.GetSecurityAttributeParentCodedIndex(node); + this.securityAttributeCount += n; + m = this.nodesWithSecurityAttributes.Count; + this.nodesWithSecurityAttributes.Add(node); + int i = 0; //after the for loop i will be position where the new node should be in sorted list + NodeList nodes = this.nodesWithSecurityAttributes; + for (i = m; i > 0; i--) + { + Node other = nodes[i - 1]; + int oci = this.GetSecurityAttributeParentCodedIndex(other); + if (oci < codedIndex) break; + } + if (i == m) return; //node is already where it should be + for (int j = m; j > i; j--) nodes[j] = nodes[j - 1]; //Make space at postion i + nodes[i] = node; + } + void VisitStatement(Statement/*!*/ statement) + { + this.DefineSequencePoint(statement); + switch (statement.NodeType) + { + case NodeType.Nop: this.methodBodyHeap.Write((byte)0x00); break; + case NodeType.DebugBreak: this.methodBodyHeap.Write((byte)0x01); break; + case NodeType.EndFinally: this.methodBodyHeap.Write((byte)0xdc); break; + } + } + void VisitStruct(Struct/*!*/ Struct) + { + if (this.UseGenerics && Struct.Template != null && Struct.Template.IsGeneric) return; + this.VisitAttributeList(Struct.Attributes, Struct); + this.VisitSecurityAttributeList(Struct.SecurityAttributes, Struct); + this.VisitReferencedType(CoreSystemTypes.ValueType); + InterfaceList interfaces = Struct.Interfaces; + for (int i = 0, n = interfaces == null ? 0 : interfaces.Count; i < n; i++) + { + this.GetTypeDefOrRefOrSpecEncoded(interfaces[i]); + if (interfaces[i] != null) this.interfaceEntries.Add(Struct); + } + for (int i = 0, n = Struct.Members.Count; i < n; i++) + { + Member m = Struct.Members[i]; + if (m is TypeNode) continue; + this.Visit(m); + } + if ((Struct.Flags & (TypeFlags.ExplicitLayout | TypeFlags.SequentialLayout)) != 0 && (Struct.PackingSize != 0 || Struct.ClassSize != 0)) + this.classLayoutEntries.Add(Struct); + } + void VisitSwitchInstruction(SwitchInstruction/*!*/ switchInstruction) + { + this.Visit(switchInstruction.Expression); + this.stackHeight--; + BlockList targets = switchInstruction.Targets; + int n = targets != null ? targets.Count : 0; + int addressOfNextInstruction = ((int)this.methodBodyHeap.BaseStream.Position) + 5 + 4 * n; + this.methodBodyHeap.Write((byte)0x45); + this.methodBodyHeap.Write((uint)n); + for (int i = 0; i < n; i++) + this.methodBodyHeap.Write((int)this.GetOffset(targets[i], addressOfNextInstruction)); + } + void VisitTernaryExpression(TernaryExpression/*!*/ expression) + { + this.Visit(expression.Operand1); + this.Visit(expression.Operand2); + this.Visit(expression.Operand3); + this.methodBodyHeap.Write((byte)0xfe); + if (expression.NodeType == NodeType.Cpblk) + this.methodBodyHeap.Write((byte)0x17); + else + this.methodBodyHeap.Write((byte)0x18); + this.stackHeight -= 3; + } + void VisitThis(This/*!*/ This) + { + this.IncrementStackHeight(); + this.methodBodyHeap.Write((byte)0x02); + } + void VisitThrow(Throw/*!*/ Throw) + { + this.DefineSequencePoint(Throw); + if (Throw.NodeType == NodeType.Rethrow) + { + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x1a); + } + else + { + this.Visit(Throw.Expression); + this.methodBodyHeap.Write((byte)0x7a); + } + this.stackHeight--; + } + void VisitUnaryExpression(UnaryExpression/*!*/ unaryExpression) + { + switch (unaryExpression.NodeType) + { + case NodeType.Ldtoken: + this.methodBodyHeap.Write((byte)0xd0); + Literal lit = unaryExpression.Operand as Literal; + if (lit != null) + { + if (lit.Value == null) return; + this.methodBodyHeap.Write((int)this.GetTypeDefToken((TypeNode)lit.Value)); + } + else + { + if (unaryExpression.Operand == null) return; + Member m = ((MemberBinding)unaryExpression.Operand).BoundMember; + if (m == null) return; + Method meth = m as Method; + if (meth != null) + this.methodBodyHeap.Write((int)this.GetMethodToken(meth)); + else + this.methodBodyHeap.Write((int)this.GetFieldToken((Field)m)); + } + this.IncrementStackHeight(); + return; + + case NodeType.Ldftn: + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x06); + this.methodBodyHeap.Write((int)this.GetMethodToken((Method)((MemberBinding)unaryExpression.Operand).BoundMember)); + this.IncrementStackHeight(); + return; + + case NodeType.Sizeof: + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x1c); + this.methodBodyHeap.Write((int)this.GetTypeToken((TypeNode)((Literal)unaryExpression.Operand).Value)); + this.IncrementStackHeight(); + return; + + case NodeType.SkipCheck: + this.methodBodyHeap.Write((byte)0xfe); + this.methodBodyHeap.Write((byte)0x19); + switch (unaryExpression.Operand.NodeType) + { + case NodeType.Castclass: + case NodeType.Unbox: + this.methodBodyHeap.Write((byte)0x01); + break; + default: + Debug.Assert(false); + this.methodBodyHeap.Write((byte)0x00); + break; + } + this.VisitExpression(unaryExpression.Operand); + return; + } + this.Visit(unaryExpression.Operand); + byte opCode = 0; + switch (unaryExpression.NodeType) + { + case NodeType.Neg: opCode = 0x65; break; + case NodeType.Not: opCode = 0x66; break; + case NodeType.Conv_I1: opCode = 0x67; break; + case NodeType.Conv_I2: opCode = 0x68; break; + case NodeType.Conv_I4: opCode = 0x69; break; + case NodeType.Conv_I8: opCode = 0x6a; break; + case NodeType.Conv_R4: opCode = 0x6b; break; + case NodeType.Conv_R8: opCode = 0x6c; break; + case NodeType.Conv_U4: opCode = 0x6d; break; + case NodeType.Conv_U8: opCode = 0x6e; break; + case NodeType.Conv_R_Un: opCode = 0x76; break; + case NodeType.Conv_Ovf_I1_Un: opCode = 0x82; break; + case NodeType.Conv_Ovf_I2_Un: opCode = 0x83; break; + case NodeType.Conv_Ovf_I4_Un: opCode = 0x84; break; + case NodeType.Conv_Ovf_I8_Un: opCode = 0x85; break; + case NodeType.Conv_Ovf_U1_Un: opCode = 0x86; break; + case NodeType.Conv_Ovf_U2_Un: opCode = 0x87; break; + case NodeType.Conv_Ovf_U4_Un: opCode = 0x88; break; + case NodeType.Conv_Ovf_U8_Un: opCode = 0x89; break; + case NodeType.Conv_Ovf_I_Un: opCode = 0x8a; break; + case NodeType.Conv_Ovf_U_Un: opCode = 0x8b; break; + case NodeType.Ldlen: opCode = 0x8e; break; + case NodeType.Conv_Ovf_I1: opCode = 0xb3; break; + case NodeType.Conv_Ovf_U1: opCode = 0xb4; break; + case NodeType.Conv_Ovf_I2: opCode = 0xb5; break; + case NodeType.Conv_Ovf_U2: opCode = 0xb6; break; + case NodeType.Conv_Ovf_I4: opCode = 0xb7; break; + case NodeType.Conv_Ovf_U4: opCode = 0xb8; break; + case NodeType.Conv_Ovf_I8: opCode = 0xb9; break; + case NodeType.Conv_Ovf_U8: opCode = 0xba; break; + case NodeType.Ckfinite: opCode = 0xc3; break; + case NodeType.Conv_U2: opCode = 0xd1; break; + case NodeType.Conv_U1: opCode = 0xd2; break; + case NodeType.Conv_I: opCode = 0xd3; break; + case NodeType.Conv_Ovf_I: opCode = 0xd4; break; + case NodeType.Conv_Ovf_U: opCode = 0xd5; break; + case NodeType.Conv_U: opCode = 0xe0; break; + case NodeType.Localloc: opCode = 0x0f; this.methodBodyHeap.Write((byte)0xfe); break; + case NodeType.Refanytype: opCode = 0x1d; this.methodBodyHeap.Write((byte)0xfe); break; + } + this.methodBodyHeap.Write((byte)opCode); + } + static void WriteArrayShape(BinaryWriter/*!*/ target, ArrayType/*!*/ arrayType) + { + Ir2md.WriteCompressedInt(target, arrayType.Rank); + int n = arrayType.Sizes == null ? 0 : arrayType.Sizes.Length; + Ir2md.WriteCompressedInt(target, n); + for (int i = 0; i < n; i++) + { + //^ assert arrayType.Sizes != null; + Ir2md.WriteCompressedInt(target, arrayType.Sizes[i]); + } + n = arrayType.LowerBounds == null ? 0 : arrayType.LowerBounds.Length; + Ir2md.WriteCompressedInt(target, n); + for (int i = 0; i < n; i++) + { + //^ assert arrayType.LowerBounds != null; + Ir2md.WriteCompressedInt(target, arrayType.LowerBounds[i]); + } + } + internal static void WriteCompressedInt(BinaryWriter/*!*/ target, int val) + { + if (val <= 0x7f) + target.Write((byte)val); + else if (val < 0x3fff) + { + target.Write((byte)((val >> 8) | 0x80)); + target.Write((byte)(val & 0xff)); + } + else if (val < 0x1fffffff) + { + target.Write((byte)((val >> 24) | 0xc0)); + target.Write((byte)((val & 0xff0000) >> 16)); + target.Write((byte)((val & 0xff00) >> 8)); + target.Write((byte)(val & 0xff)); + } + else + Debug.Assert(false, "index too large for compression"); + } + TypeNode/*!*/ WriteCustomModifiers(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + switch (type.NodeType) + { + case NodeType.RequiredModifier: + case NodeType.OptionalModifier: + TypeModifier tm = (TypeModifier)type; + target.Write((byte)tm.typeCode); + this.WriteTypeDefOrRefEncoded(target, tm.Modifier); + return this.WriteCustomModifiers(target, tm.ModifiedType); + } + return type; + } + void WriteCustomAttributeLiteral(BinaryWriter/*!*/ writer, Literal/*!*/ literal, bool needsTag) + { + if (literal.Type == null) return; + ElementType typeCode = literal.Type.typeCode; + if (needsTag) + { + if (typeCode == ElementType.ValueType) + { //Boxed enum + writer.Write((byte)0x55); + this.WriteSerializedTypeName(writer, literal.Type); + } + else if (typeCode == ElementType.Class) + { //a Type value + writer.Write((byte)0x50); + } + else if (typeCode != ElementType.Object) //a primitive + writer.Write((byte)typeCode); + } + Object value = literal.Value; + //if (value == null) return; //TODO: nope, find some other way + switch (typeCode) + { + case ElementType.Boolean: writer.Write((bool)value); return; + case ElementType.Char: writer.Write((ushort)(char)value); return; + case ElementType.Double: writer.Write((double)value); return; + case ElementType.Single: writer.Write((float)value); return; + case ElementType.Int16: writer.Write((short)value); return; + case ElementType.Int32: writer.Write((int)value); return; + case ElementType.Int64: writer.Write((long)value); return; + case ElementType.Int8: writer.Write((sbyte)value); return; + case ElementType.UInt16: writer.Write((ushort)value); return; + case ElementType.UInt32: writer.Write((uint)value); return; + case ElementType.UInt64: writer.Write((ulong)value); return; + case ElementType.UInt8: writer.Write((byte)value); return; + case ElementType.String: writer.Write((string)value, false); return; + case ElementType.ValueType: this.WriteCustomAttributeLiteral(writer, new Literal(value, ((EnumNode)literal.Type).UnderlyingType), false); return; + case ElementType.Class: this.WriteSerializedTypeName(writer, (TypeNode)value); return; + case ElementType.SzArray: + TypeNode elemType = ((ArrayType)literal.Type).ElementType; + if (needsTag) + writer.Write((byte)elemType.typeCode); + Array array = (Array)value; + int numElems = array == null ? -1 : array.Length; + writer.Write((int)numElems); + for (int i = 0; i < numElems; i++) + this.WriteCustomAttributeLiteral(writer, new Literal(array.GetValue(i), elemType), false); + return; + case ElementType.Object: + Literal lit = (Literal)literal.Clone(); + TypeNode t = null; + switch (Convert.GetTypeCode(lit.Value)) + { + case TypeCode.Boolean: t = CoreSystemTypes.Boolean; break; + case TypeCode.Byte: t = CoreSystemTypes.UInt8; break; + case TypeCode.Char: t = CoreSystemTypes.Char; break; + case TypeCode.Double: t = CoreSystemTypes.Double; break; + case TypeCode.Int16: t = CoreSystemTypes.Int16; break; + case TypeCode.Int32: t = CoreSystemTypes.Int32; break; + case TypeCode.Int64: t = CoreSystemTypes.Int64; break; + case TypeCode.SByte: t = CoreSystemTypes.Int8; break; + case TypeCode.Single: t = CoreSystemTypes.Single; break; + case TypeCode.String: t = CoreSystemTypes.String; break; + case TypeCode.UInt16: t = CoreSystemTypes.UInt16; break; + case TypeCode.UInt32: t = CoreSystemTypes.UInt32; break; + case TypeCode.UInt64: t = CoreSystemTypes.UInt64; break; + case TypeCode.Empty: + case TypeCode.Object: + Array arr = lit.Value as Array; + if (arr != null) + { +#if !NoReflection + t = TypeNode.GetTypeNode(arr.GetType()); +#else + System.Type reflType = arr.GetType(); + System.Type reflElemType = reflType.GetElementType(); + AssemblyNode assem = AssemblyNode.GetAssembly(reflType.Assembly.Location); + TypeNode cciElemType = assem.GetType(Identifier.For(reflElemType.Namespace), Identifier.For(reflElemType.Name)); + t = cciElemType.GetArrayType(reflType.GetArrayRank()); +#endif + } + else + t = CoreSystemTypes.Type; + break; + } + if (t == null) break; + lit.Type = t; + this.WriteCustomAttributeLiteral(writer, lit, true); + return; + } + Debug.Assert(false, "Unexpected type in custom attribute"); + } + bool AttributesContains(AttributeList al, TypeNode/*!*/ a) + { + if (al == null) return false; + for (int i = 0, n = al.Count; i < n; i++) + { + if (al[i] != null && al[i].Type == a) + return true; + } + return false; + } + void WriteMethodSignature(BinaryWriter/*!*/ target, Method/*!*/ method) + { + if (this.UseGenerics) + { + if (method.Template != null && method.Template.IsGeneric) + { + //Signature is being used in MethodDef table + TypeNodeList types = method.TemplateArguments; + int m = types == null ? 0 : types.Count; + target.Write((byte)(method.CallingConvention | CallingConventionFlags.Generic)); + Ir2md.WriteCompressedInt(target, m); + } + else if (method.DeclaringType.Template != null && method.DeclaringType.Template.IsGeneric) + { + Method unspecializedMethod = this.GetUnspecializedMethod(method); + this.WriteMethodSignature(target, unspecializedMethod); + return; + } + else if (method.IsGeneric) + { + TypeNodeList types = method.TemplateParameters; + int m = types == null ? 0 : types.Count; + target.Write((byte)(method.CallingConvention | CallingConventionFlags.Generic)); + Ir2md.WriteCompressedInt(target, m); + } + else + target.Write((byte)method.CallingConvention); + } + else + target.Write((byte)method.CallingConvention); + ParameterList pars = method.Parameters; + int n = pars == null ? 0 : pars.Count; + Ir2md.WriteCompressedInt(target, n); + + TypeNode returnType = method.ReturnType; +#if ExtendedRuntime + if (method.HasOutOfBandContract || this.AttributesContains(method.ReturnAttributes, SystemTypes.NotNullAttribute)) { + returnType = TypeNode.DeepStripModifiers(returnType, (method.Template != null) ? method.Template.ReturnType : null, SystemTypes.NonNullType, SystemTypes.NullableType); + // returnType = TypeNode.DeepStripModifier(returnType, SystemTypes.NullableType, (method.Template != null) ? returnType.GetTemplateInstance(returnType, returnType.TemplateArguments) : null); + } +#endif + if (returnType == null) returnType = SystemTypes.Object; + this.WriteTypeSignature(target, returnType, true); + for (int i = 0; i < n; i++) + { + Parameter p = pars[i]; + if (p == null) continue; + TypeNode parameterType = p.Type; +#if ExtendedRuntime + if (method.HasOutOfBandContract || this.AttributesContains(p.Attributes, SystemTypes.NotNullAttribute)) { + parameterType = TypeNode.DeepStripModifiers(parameterType, (method.Template != null) ? method.Template.Parameters[i].Type : null, SystemTypes.NonNullType, SystemTypes.NullableType); + //parameterType = TypeNode.DeepStripModifier(parameterType, SystemTypes.NullableType, (method.Template != null) ? parameterType.GetTemplateInstance(parameterType, parameterType.TemplateArguments) : null); + } +#endif + if (parameterType == null) parameterType = SystemTypes.Object; + this.WriteTypeSignature(target, parameterType); + } + } + void WriteMethodSpecSignature(BinaryWriter/*!*/ target, Method/*!*/ method) + //^ requires this.UseGenerics && method.Template != null && method.Template.IsGeneric; + { + Debug.Assert(this.UseGenerics && method.Template != null && method.Template.IsGeneric); + target.Write((byte)0x0a); + TypeNodeList types = method.TemplateArguments; + int m = types == null ? 0 : types.Count; + Ir2md.WriteCompressedInt(target, m); + for (int i = 0; i < m; i++) + { + //^ assert types != null; + this.WriteTypeSignature(target, types[i]); + } + } + void WriteMethodSignature(BinaryWriter/*!*/ target, FunctionPointer/*!*/ fp) + { + target.Write((byte)fp.CallingConvention); + TypeNodeList parTypes = fp.ParameterTypes; + int n = parTypes == null ? 0 : parTypes.Count; + Ir2md.WriteCompressedInt(target, n); + if (fp.ReturnType != null) + this.WriteTypeSignature(target, fp.ReturnType); + int m = fp.VarArgStart; + for (int i = 0; i < n; i++) + { + //^ assert parTypes != null; + if (i == m) target.Write((byte)0x41); //Sentinel + this.WriteTypeSignature(target, parTypes[i]); + } + } + void WritePropertySignature(BinaryWriter/*!*/ target, Property/*!*/ prop) + { + byte propHeader = (byte)0x8; + if (!prop.IsStatic) propHeader |= (byte)0x20; //bizarre redundant way to indicate that property accessors are instance methods + target.Write(propHeader); + ParameterList pars = prop.Parameters; + int n = pars == null ? 0 : pars.Count; + Ir2md.WriteCompressedInt(target, n); + if (prop.Type != null) this.WriteTypeSignature(target, prop.Type); + for (int i = 0; i < n; i++) + { + //^ assert pars != null; + Parameter par = pars[i]; + if (par == null || par.Type == null) continue; + this.WriteTypeSignature(target, par.Type); + } + } + void WriteSerializedTypeName(BinaryWriter target, TypeNode type) + { + if (target == null || type == null) return; + target.Write(this.GetSerializedTypeName(type), false); + } + string GetSerializedTypeName(TypeNode/*!*/ type) + { + bool isAssemblyQualified = true; + return this.GetSerializedTypeName(type, ref isAssemblyQualified); + } + string GetSerializedTypeName(TypeNode/*!*/ type, ref bool isAssemblyQualified) + { + if (type == null) return null; + this.VisitReferencedType(type); + StringBuilder sb = new StringBuilder(); + TypeModifier tMod = type as TypeModifier; + if (tMod != null) + { + sb.Append(this.GetTypeDefOrRefOrSpecEncoded(type)); + sb.Append('!'); + return sb.ToString(); + } + ArrayType arrType = type as ArrayType; + if (arrType != null) + { + type = arrType.ElementType; + bool isAssemQual = false; + this.AppendSerializedTypeName(sb, arrType.ElementType, ref isAssemQual); + if (arrType.IsSzArray()) + sb.Append("[]"); + else + { + sb.Append('['); + if (arrType.Rank == 1) sb.Append('*'); + for (int i = 1; i < arrType.Rank; i++) sb.Append(','); + sb.Append(']'); + } + goto done; + } + Pointer pointer = type as Pointer; + if (pointer != null) + { + type = pointer.ElementType; + bool isAssemQual = false; + this.AppendSerializedTypeName(sb, pointer.ElementType, ref isAssemQual); + sb.Append('*'); + goto done; + } + Reference reference = type as Reference; + if (reference != null) + { + type = reference.ElementType; + bool isAssemQual = false; + this.AppendSerializedTypeName(sb, reference.ElementType, ref isAssemQual); + sb.Append('&'); + goto done; + } + if (type.Template == null) + sb.Append(type.FullName); + else + { + sb.Append(type.Template.FullName); + sb.Append('['); + for (int i = 0, n = type.TemplateArguments == null ? 0 : type.TemplateArguments.Count; i < n; i++) + { + //^ assert type.TemplateArguments != null; + bool isAssemQual = true; + this.AppendSerializedTypeName(sb, type.TemplateArguments[i], ref isAssemQual); + if (i < n - 1) sb.Append(','); + } + sb.Append(']'); + } + done: + if (isAssemblyQualified) + this.AppendAssemblyQualifierIfNecessary(sb, type, out isAssemblyQualified); + return sb.ToString(); + } + void AppendAssemblyQualifierIfNecessary(StringBuilder/*!*/ sb, TypeNode type, out bool isAssemQualified) + { + isAssemQualified = false; + if (type == null) return; + AssemblyNode referencedAssembly = type.DeclaringModule as AssemblyNode; + if (referencedAssembly != null && referencedAssembly != this.module /*&& referencedAssembly != CoreSystemTypes.SystemAssembly*/) + { + sb.Append(", "); + sb.Append(referencedAssembly.StrongName); + isAssemQualified = true; + } + } + void AppendSerializedTypeName(StringBuilder/*!*/ sb, TypeNode type, ref bool isAssemQualified) + { + if (type == null) return; + string argTypeName = this.GetSerializedTypeName(type, ref isAssemQualified); + if (isAssemQualified) sb.Append('['); + sb.Append(argTypeName); + if (isAssemQualified) sb.Append(']'); + } + void WriteTypeDefOrRefEncoded(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + if (!type.IsGeneric && this.IsStructural(type) && !(type is ITypeParameter)) + this.WriteTypeSpecEncoded(target, type); + else if (type.DeclaringModule == this.module) + this.WriteTypeDefEncoded(target, type); + else if (type.DeclaringModule != null) + this.WriteTypeRefEncoded(target, type); + else + Debug.Assert(false); + } + void WriteTypeDefEncoded(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + int tok = this.GetTypeDefIndex(type); + Ir2md.WriteCompressedInt(target, (tok << 2)); + } + void WriteTypeRefEncoded(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + int tok = this.GetTypeRefIndex(type); + Ir2md.WriteCompressedInt(target, (tok << 2) | 1); + } + void WriteTypeSpecEncoded(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + int tok = this.GetTypeSpecIndex(type); + Ir2md.WriteCompressedInt(target, (tok << 2) | 2); + } + void WriteTypeSignature(BinaryWriter/*!*/ target, TypeNode/*!*/ type) + { + this.WriteTypeSignature(target, type, false); + } + void WriteTypeSignature(BinaryWriter/*!*/ target, TypeNode/*!*/ type, bool instantiateGenericTypes) + { + if (type == null) return; + TypeNode t = this.WriteCustomModifiers(target, type); + if (this.UseGenerics) + { + if (t.Template != null && t.Template.IsGeneric && t.TemplateParameters == null) + { + target.Write((byte)0x15); + TypeNode template = t.Template; + while (template.Template != null) template = template.Template; + this.WriteTypeSignature(target, template); + TypeNodeList templArgs = t.ConsolidatedTemplateArguments; + int n = templArgs == null ? 0 : templArgs.Count; + Ir2md.WriteCompressedInt(target, n); + for (int i = 0; i < n; i++) + { + //^ assume templArgs != null; + TypeNode targ = templArgs[i]; + if (targ == null) continue; + this.WriteTypeSignature(target, targ); + } + return; + } + else if (t.IsGeneric && instantiateGenericTypes) + { + while (t.Template != null) t = t.Template; + target.Write((byte)0x15); + this.WriteTypeSignature(target, t); + TypeNodeList templPars = t.ConsolidatedTemplateParameters; + int n = templPars == null ? 0 : templPars.Count; + Ir2md.WriteCompressedInt(target, n); + for (int i = 0; i < n; i++) + { + //^ assume templPars != null; + TypeNode tp = templPars[i]; + if (tp == null) continue; + this.WriteTypeSignature(target, tp); + } + return; + } + if (t is ITypeParameter) + { + object num = this.typeParameterNumber[t.UniqueKey]; + if (num is int) + { + int number = (int)num; + if (number < 0) + { + target.Write((byte)0x1e); number = -number; + } + else + target.Write((byte)0x13); + Ir2md.WriteCompressedInt(target, number - 1); + return; + } + } + } + target.Write((byte)t.typeCode); + switch (t.typeCode) + { + case ElementType.Pointer: this.WriteTypeSignature(target, ((Pointer)t).ElementType); break; + case ElementType.Reference: this.WriteTypeSignature(target, ((Reference)t).ElementType); break; + case ElementType.ValueType: + case ElementType.Class: this.WriteTypeDefOrRefEncoded(target, t); break; + case ElementType.Array: this.WriteTypeSignature(target, ((ArrayType)t).ElementType); Ir2md.WriteArrayShape(target, (ArrayType)t); break; + case ElementType.FunctionPointer: this.WriteMethodSignature(target, (FunctionPointer)t); break; + case ElementType.SzArray: this.WriteTypeSignature(target, ((ArrayType)t).ElementType); break; + } + } + +#if !ROTOR + void IMetaDataEmit.SetModuleProps(string szName) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.Save(string szFile, uint dwSaveFlags) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SaveToStream(void* pIStream, uint dwSaveFlags) + { + throw new NotImplementedException(); + } + uint IMetaDataEmit.GetSaveSize(uint fSave) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineTypeDef(char* szTypeDef, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineNestedType(char* szTypeDef, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements, uint tdEncloser) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetHandler([MarshalAs(UnmanagedType.IUnknown), In]object pUnk) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineMethod(uint td, char* zName, uint dwMethodFlags, byte* pvSigBlob, uint cbSigBlob, uint ulCodeRVA, uint dwImplFlags) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DefineMethodImpl(uint td, uint tkBody, uint tkDecl) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineTypeRefByName(uint tkResolutionScope, char* szName) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineImportType(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, IMetaDataImport pImport, + uint tdImport, IntPtr pAssemEmit) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineMemberRef(uint tkImport, string szName, byte* pvSigBlob, uint cbSigBlob) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineImportMember(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, + IMetaDataImport pImport, uint mbMember, IntPtr pAssemEmit, uint tkParent) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineEvent(uint td, string szEvent, uint dwEventFlags, uint tkEventType, uint mdAddOn, uint mdRemoveOn, uint mdFire, uint* rmdOtherMethods) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetClassLayout(uint td, uint dwPackSize, COR_FIELD_OFFSET* rFieldOffsets, uint ulClassSize) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DeleteClassLayout(uint td) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetFieldMarshal(uint tk, byte* pvNativeType, uint cbNativeType) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DeleteFieldMarshal(uint tk) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefinePermissionSet(uint tk, uint dwAction, void* pvPermission, uint cbPermission) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetRVA(uint md, uint ulRVA) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.GetTokenFromSig(byte* pvSig, uint cbSig) + { + BinaryWriter sig = new BinaryWriter(new MemoryStream()); + for (int i = 0; i < cbSig; i++) sig.Write(*(pvSig + i)); + return (uint)(0x11000000 | this.GetStandAloneSignatureIndex(sig)); + } + uint IMetaDataEmit.DefineModuleRef(string szName) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetParent(uint mr, uint tk) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.GetTokenFromTypeSpec(byte* pvSig, uint cbSig) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SaveToMemory(void* pbData, uint cbData) + { + throw new NotImplementedException(); + } + uint IMetaDataEmit.DefineUserString(string szString, uint cchString) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DeleteToken(uint tkObj) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetMethodProps(uint md, uint dwMethodFlags, uint ulCodeRVA, uint dwImplFlags) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetTypeDefProps(uint td, uint dwTypeDefFlags, uint tkExtends, uint* rtkImplements) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetEventProps(uint ev, uint dwEventFlags, uint tkEventType, uint mdAddOn, uint mdRemoveOn, uint mdFire, uint* rmdOtherMethods) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.SetPermissionSetProps(uint tk, uint dwAction, void* pvPermission, uint cbPermission) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DefinePinvokeMap(uint tk, uint dwMappingFlags, string szImportName, uint mrImportDLL) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetPinvokeMap(uint tk, uint dwMappingFlags, string szImportName, uint mrImportDLL) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.DeletePinvokeMap(uint tk) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineCustomAttribute(uint tkObj, uint tkType, void* pCustomAttribute, uint cbCustomAttribute) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetCustomAttributeValue(uint pcv, void* pCustomAttribute, uint cbCustomAttribute) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineField(uint td, string szName, uint dwFieldFlags, byte* pvSigBlob, uint cbSigBlob, uint dwCPlusTypeFlag, + void* pValue, uint cchValue) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineProperty(uint td, string szProperty, uint dwPropFlags, byte* pvSig, uint cbSig, uint dwCPlusTypeFlag, + void* pValue, uint cchValue, uint mdSetter, uint mdGetter, uint* rmdOtherMethods) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.DefineParam(uint md, uint ulParamSeq, string szName, uint dwParamFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetFieldProps(uint fd, uint dwFieldFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetPropertyProps(uint pr, uint dwPropFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue, uint mdSetter, uint mdGetter, uint* rmdOtherMethods) + { + throw new NotImplementedException(); + } + unsafe void IMetaDataEmit.SetParamProps(uint pd, string szName, uint dwParamFlags, uint dwCPlusTypeFlag, void* pValue, uint cchValue) + { + throw new NotImplementedException(); + } + uint IMetaDataEmit.DefineSecurityAttributeSet(uint tkObj, IntPtr rSecAttrs, uint cSecAttrs) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.ApplyEditAndContinue([MarshalAs(UnmanagedType.IUnknown)]object pImport) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataEmit.TranslateSigWithScope(IntPtr pAssemImport, void* pbHashValue, uint cbHashValue, + IMetaDataImport import, byte* pbSigBlob, uint cbSigBlob, IntPtr pAssemEmit, IMetaDataEmit emit, byte* pvTranslatedSig, uint cbTranslatedSigMax) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetMethodImplFlags(uint md, uint dwImplFlags) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.SetFieldRVA(uint fd, uint ulRVA) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.Merge(IMetaDataImport pImport, IntPtr pHostMapToken, [MarshalAs(UnmanagedType.IUnknown)]object pHandler) + { + throw new NotImplementedException(); + } + void IMetaDataEmit.MergeEnd() + { + throw new NotImplementedException(); + } + [PreserveSig] + void IMetaDataImport.CloseEnum(uint hEnum) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.CountEnum(uint hEnum) + { + throw new NotImplementedException(); + } + void IMetaDataImport.ResetEnum(uint hEnum, uint ulPos) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumTypeDefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeDefs, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumInterfaceImpls(ref uint phEnum, uint td, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rImpls, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumTypeRefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeRefs, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindTypeDefByName(string szTypeDef, uint tkEnclosingClass) + { + throw new NotImplementedException(); + } + Guid IMetaDataImport.GetScopeProps(StringBuilder szName, uint cchName, out uint pchName) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetModuleFromScope() + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetTypeDefProps(uint td, IntPtr szTypeDef, uint cchTypeDef, out uint pchTypeDef, IntPtr pdwTypeDefFlags) + { + pchTypeDef = 0; + if (td == 0) return 0; + TypeNode t = null; + if ((td & 0xFF000000) == 0x1B000000) + { + t = this.typeSpecEntries[(int)(td & 0xFFFFFF) - 1]; + if (t.Template != null) t = t.Template; + } + else + t = this.typeDefEntries[(int)(td & 0xFFFFFF) - 1]; + if (t == null || t.Name == null) return 0; + string tName = t.Name.ToString(); + if (tName == null) return 0; + pchTypeDef = (uint)tName.Length; + if (pchTypeDef >= cchTypeDef) pchTypeDef = cchTypeDef - 1; + char* pTypeDef = (char*)szTypeDef.ToPointer(); + for (int i = 0; i < pchTypeDef; i++) *(pTypeDef + i) = tName[i]; + *(pTypeDef + pchTypeDef) = (char)0; + uint* pFlags = (uint*)pdwTypeDefFlags.ToPointer(); + *(pFlags) = (uint)t.Flags; + TypeNode bt = t.BaseType; + if (bt == null) return 0; + return (uint)this.GetTypeToken(bt); + } + uint IMetaDataImport.GetInterfaceImplProps(uint iiImpl, out uint pClass) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetTypeRefProps(uint tr, out uint ptkResolutionScope, StringBuilder szName, uint cchName) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.ResolveTypeRef(uint tr, [In] ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppIScope) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMembers(ref uint phEnum, uint cl, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rMembers, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMembersWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMembers, uint cMax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.EnumMethods(ref uint phEnum, uint cl, uint* rMethods, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMethodsWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethods, uint cMax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.EnumFields(ref uint phEnum, uint cl, uint* rFields, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumFieldsWithName(ref uint phEnum, uint cl, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rFields, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumParams(ref uint phEnum, uint mb, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rParams, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMemberRefs(ref uint phEnum, uint tkParent, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rMemberRefs, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMethodImpls(ref uint phEnum, uint td, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethodBody, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rMethodDecl, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumPermissionSets(ref uint phEnum, uint tk, uint dwActions, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rPermission, + uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindMember(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindMethod(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindField(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindMemberRef(uint td, string szName, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] byte[] pvSigBlob, uint cbSigBlob) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetMethodProps(uint mb, out uint pClass, IntPtr szMethod, uint cchMethod, out uint pchMethod, IntPtr pdwAttr, + IntPtr ppvSigBlob, IntPtr pcbSigBlob, IntPtr pulCodeRVA) + { + Method m = null; + if ((mb & 0xFF000000) == 0x0A000000) + m = this.memberRefEntries[(int)(mb & 0xFFFFFF) - 1] as Method; + else + m = this.methodEntries[(int)(mb & 0xFFFFFF) - 1]; + pchMethod = 0; + pClass = 0; + if (m == null || m.DeclaringType == null) return 0; + pClass = (uint)this.GetTypeDefToken(m.DeclaringType); + string methName = m.Name == null ? null : m.Name.ToString(); + if (methName == null) return 0; + pchMethod = (uint)methName.Length; + char* pMethName = (char*)szMethod.ToPointer(); + for (int i = 0; i < pchMethod; i++) *(pMethName + i) = methName[i]; + *(pMethName + pchMethod) = (char)0; + return 0; + } + unsafe uint IMetaDataImport.GetMemberRefProps(uint mr, ref uint ptk, StringBuilder szMember, uint cchMember, out uint pchMember, out byte* ppvSigBlob) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.EnumProperties(ref uint phEnum, uint td, uint* rProperties, uint cMax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.EnumEvents(ref uint phEnum, uint td, uint* rEvents, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetEventProps(uint ev, out uint pClass, StringBuilder szEvent, uint cchEvent, out uint pchEvent, out uint pdwEventFlags, + out uint ptkEventType, out uint pmdAddOn, out uint pmdRemoveOn, out uint pmdFire, + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 11)] uint[] rmdOtherMethod, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumMethodSemantics(ref uint phEnum, uint mb, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] uint[] rEventProp, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetMethodSemantics(uint mb, uint tkEventProp) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetClassLayout(uint td, out uint pdwPackSize, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] COR_FIELD_OFFSET[] rFieldOffset, uint cMax, out uint pcFieldOffset) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetFieldMarshal(uint tk, out byte* ppvNativeType) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetRVA(uint tk, out uint pulCodeRVA) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetPermissionSetProps(uint pm, out uint pdwAction, out void* ppvPermission) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetSigFromToken(uint mdSig, out byte* ppvSig) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetModuleRefProps(uint mur, StringBuilder szName, uint cchName) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumModuleRefs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rModuleRefs, uint cmax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetTypeSpecFromToken(uint typespec, out byte* ppvSig) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetNameFromToken(uint tk) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumUnresolvedMethods(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rMethods, uint cMax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetUserString(uint stk, StringBuilder szString, uint cchString) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetPinvokeMap(uint tk, out uint pdwMappingFlags, StringBuilder szImportName, uint cchImportName, out uint pchImportName) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumSignatures(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rSignatures, uint cmax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumTypeSpecs(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rTypeSpecs, uint cmax) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumUserStrings(ref uint phEnum, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] uint[] rStrings, uint cmax) + { + throw new NotImplementedException(); + } + [PreserveSig] + int IMetaDataImport.GetParamForMethodIndex(uint md, uint ulParamSeq, out uint pParam) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.EnumCustomAttributes(ref uint phEnum, uint tk, uint tkType, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] uint[] rCustomAttributes, uint cMax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetCustomAttributeProps(uint cv, out uint ptkObj, out uint ptkType, out void* ppBlob) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.FindTypeRef(uint tkResolutionScope, string szName) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetMemberProps(uint mb, out uint pClass, StringBuilder szMember, uint cchMember, out uint pchMember, out uint pdwAttr, + out byte* ppvSigBlob, out uint pcbSigBlob, out uint pulCodeRVA, out uint pdwImplFlags, out uint pdwCPlusTypeFlag, out void* ppValue) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetFieldProps(uint mb, out uint pClass, StringBuilder szField, uint cchField, out uint pchField, out uint pdwAttr, + out byte* ppvSigBlob, out uint pcbSigBlob, out uint pdwCPlusTypeFlag, out void* ppValue) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetPropertyProps(uint prop, out uint pClass, StringBuilder szProperty, uint cchProperty, out uint pchProperty, out uint pdwPropFlags, + out byte* ppvSig, out uint pbSig, out uint pdwCPlusTypeFlag, out void* ppDefaultValue, out uint pcchDefaultValue, out uint pmdSetter, + out uint pmdGetter, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 14)] uint[] rmdOtherMethod, uint cMax) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetParamProps(uint tk, out uint pmd, out uint pulSequence, StringBuilder szName, uint cchName, out uint pchName, + out uint pdwAttr, out uint pdwCPlusTypeFlag, out void* ppValue) + { + throw new NotImplementedException(); + } + unsafe uint IMetaDataImport.GetCustomAttributeByName(uint tkObj, string szName, out void* ppData) + { + throw new NotImplementedException(); + } + [PreserveSig] + [return: MarshalAs(UnmanagedType.Bool)] + bool IMetaDataImport.IsValidToken(uint tk) + { + throw new NotImplementedException(); + } + uint IMetaDataImport.GetNestedClassProps(uint tdNestedClass) + { + TypeNode t = null; + if ((tdNestedClass & 0xFF000000) == 0x1B000000) + t = this.typeSpecEntries[(int)(tdNestedClass & 0xFFFFFF) - 1]; + else + t = this.typeDefEntries[(int)(tdNestedClass & 0xFFFFFF) - 1]; + if (t == null || t.DeclaringType == null) return 0; + return (uint)this.GetTypeToken(t.DeclaringType); + } + unsafe uint IMetaDataImport.GetNativeCallConvFromSig(void* pvSig, uint cbSig) + { + throw new NotImplementedException(); + } + int IMetaDataImport.IsGlobal(uint pd) + { + throw new NotImplementedException(); + } +#endif + } +#if WHIDBEYwithGenericsAndIEqualityComparer + public class ByteArrayKeyComparer : IEqualityComparer, IComparer + { + int IComparer.Compare(object x, object y) + { + if (x == null || y == null) throw new ArgumentNullException(); + byte[] xa = (byte[])x; + byte[] ya = (byte[])y; + int n = xa.Length; + int result = n - ya.Length; + if (result != 0) return result; + for (int i = 0; i < n; i++) + { + result = xa[i] - ya[i]; + if (result != 0) return result; + } + return 0; + } + bool IEqualityComparer.Equals(object x, object y) + { + if (x == null || y == null) return x == y; + return ((IComparer)this).Compare(x, y) == 0; + } + int IEqualityComparer.GetHashCode(object/*!*/ x) + { + Debug.Assert(x != null); + byte[] xa = (byte[])x; + int hcode = 1; + for (int i = 0, n = xa.Length; i < n; i++) + hcode = hcode * 17 + xa[i]; + return hcode; + } + } +#elif WHIDBEYwithGenerics + public class ByteArrayKeyComparer : IKeyComparer{ + int IComparer.Compare(object x, object y) { + if (x == null || y == null) throw new ArgumentNullException(); + byte[] xa = (byte[])x; + byte[] ya = (byte[])y; + int n = xa.Length; + int result = n - ya.Length; + if (result != 0) return result; + for (int i = 0; i < n; i++){ + result = xa[i] - ya[i]; + if (result != 0) return result; + } + return 0; + } + bool IKeyComparer.Equals(object x, object y){ + return ((IKeyComparer)this).Compare(x, y) == 0; + } + int IHashCodeProvider.GetHashCode(object x) { + Debug.Assert(x != null); + byte[] xa = (byte[])x; + int hcode = 1; + for (int i = 0, n = xa.Length; i < n; i++) + hcode = hcode * 17 + xa[i]; + return hcode; + } + } +#else + public class ByteArrayComparer : IComparer{ + int IComparer.Compare(object x, object y){ + if (x == null || y == null) throw new ArgumentNullException(); + byte[] xa = (byte[])x; + byte[] ya = (byte[])y; + int n = xa.Length; + int result = n - ya.Length; + if (result != 0) return result; + for (int i = 0; i < n; i++){ + result = xa[i] - ya[i]; + if (result != 0) return result; + } + return 0; + } + } + public class ByteArrayHasher : IHashCodeProvider{ + int IHashCodeProvider.GetHashCode(object x){ + Debug.Assert(x != null); + byte[] xa = (byte[])x; + int hcode = 1; + for (int i = 0, n = xa.Length; i < n; i++) + hcode = hcode*17 + xa[i]; + return hcode; + } + } +#endif + internal class Fixup + { + internal int fixupLocation; + internal int addressOfNextInstruction; + internal bool shortOffset; + internal Fixup nextFixUp; + } + internal class MethodInfo + { + internal TrivialHashtable/*!*/ fixupIndex = new TrivialHashtable(); + internal int localVarSigTok; + internal BinaryWriter/*!*/ localVarSignature; + internal TrivialHashtable/*!*/ localVarIndex; +#if !ROTOR + internal NodeList/*!*/ statementNodes; + internal LocalList/*!*/ debugLocals; + internal Int32List/*!*/ signatureLengths; + internal Int32List/*!*/ signatureOffsets; + internal Int32List/*!*/ statementOffsets; +#endif + + public MethodInfo() + { + //^ base(); + } + } + public class KeyFileNotFoundException : System.ArgumentException { } + public class AssemblyCouldNotBeSignedException : System.ApplicationException { } + public class DebugSymbolsCouldNotBeWrittenException : System.ApplicationException { } + internal class Writer + { + private Writer() { } + internal static void WritePE(System.CodeDom.Compiler.CompilerParameters/*!*/ compilerParameters, Module/*!*/ module) + //^ requires module.Location != null; + { + if (compilerParameters == null) { Debug.Assert(false); return; } + CompilerOptions options = compilerParameters as CompilerOptions; + if (options == null) + Writer.WritePE(module.Location, compilerParameters.IncludeDebugInformation, module, false, null, null); + else + { + if (options.FileAlignment > 512) module.FileAlignment = options.FileAlignment; + Writer.WritePE(module.Location, options.IncludeDebugInformation, module, options.DelaySign, options.AssemblyKeyFile, options.AssemblyKeyName); + } + } + internal static void WritePE(string/*!*/ location, bool writeDebugSymbols, Module/*!*/ module) + { + Writer.WritePE(location, writeDebugSymbols, module, false, null, null); + } + private static void WritePE(string/*!*/ location, bool writeDebugSymbols, Module/*!*/ module, bool delaySign, string keyFileName, string keyName) + { + AssemblyNode assem = module as AssemblyNode; + location = Path.GetFullPath(location); + module.Directory = Path.GetDirectoryName(location); + bool keyFileNameDoesNotExist = false; + if (assem != null) + { + assem.KeyContainerName = keyName; + if (keyFileName != null && keyFileName.Length > 0) + { + if (!File.Exists(keyFileName)) keyFileName = Path.Combine(module.Directory, keyFileName); + if (File.Exists(keyFileName)) + { + using (FileStream keyFile = File.OpenRead(keyFileName)) + { + long size = keyFile.Length; + if (size > int.MaxValue) throw new System.IO.FileLoadException(); + int n = (int)size; + byte[] key = new byte[n]; + keyFile.Read(key, 0, n); + assem.KeyBlob = key; + } + } + else + keyFileNameDoesNotExist = true; + } + assem.PublicKeyOrToken = Writer.GetPublicKey(assem); + } + using (FileStream exeFstream = new FileStream(location, FileMode.Create, FileAccess.Write, FileShare.None)) + { + string debugSymbolsLocation = writeDebugSymbols ? Path.ChangeExtension(location, "pdb") : null; + if (debugSymbolsLocation != null && File.Exists(debugSymbolsLocation)) + File.Delete(debugSymbolsLocation); + MemoryStream exeMstream = new MemoryStream(); + Ir2md.WritePE(module, debugSymbolsLocation, new BinaryWriter(exeMstream)); + exeMstream.WriteTo(exeFstream); + } + if (keyFileNameDoesNotExist) throw new KeyFileNotFoundException(); + if (delaySign || assem == null) return; + if (assem.KeyBlob != null || (assem.KeyContainerName != null && assem.KeyContainerName.Length > 0)) + { + try + { + if (!Writer.StrongNameSignatureGeneration(location, keyName, assem.KeyBlob, assem.KeyBlob == null ? 0 : assem.KeyBlob.Length, IntPtr.Zero, IntPtr.Zero)) + throw new AssemblyCouldNotBeSignedException(); + } + catch + { + if (!Writer.MscorsnStrongNameSignatureGeneration(location, keyName, assem.KeyBlob, assem.KeyBlob == null ? 0 : assem.KeyBlob.Length, IntPtr.Zero, IntPtr.Zero)) + throw new AssemblyCouldNotBeSignedException(); + } + } + } + [DllImport("mscoree.dll", EntryPoint = "StrongNameSignatureGeneration", + SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, + CallingConvention = CallingConvention.StdCall)] + private static extern bool StrongNameSignatureGeneration( + string wszFilePath, // [in] valid path to the PE file for the assembly + string wszKeyContainer, // [in] desired key container name + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] + byte[] pbKeyBlob, // [in] public/private key blob (optional) + int cbKeyBlob, + IntPtr ppbSignatureBlob, // [out] signature blob + IntPtr pcbSignatureBlob); + [DllImport("mscorsn.dll", EntryPoint = "StrongNameSignatureGeneration", + SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, + CallingConvention = CallingConvention.StdCall)] + private static extern bool MscorsnStrongNameSignatureGeneration( + string wszFilePath, // [in] valid path to the PE file for the assembly + string wszKeyContainer, // [in] desired key container name + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 4)] + byte[] pbKeyBlob, // [in] public/private key blob (optional) + int cbKeyBlob, + IntPtr ppbSignatureBlob, // [out] signature blob + IntPtr pcbSignatureBlob); + private unsafe static byte[] GetPublicKey(AssemblyNode/*!*/ assem) + { + Debug.Assert(assem != null); + IntPtr publicKey = IntPtr.Zero; + int size; + try + { + if (assem.KeyBlob != null) + { + Writer.StrongNameGetPublicKey(null, assem.KeyBlob, assem.KeyBlob.Length, out publicKey, out size); + if (publicKey == IntPtr.Zero) return assem.KeyBlob; + } + else if (assem.KeyContainerName != null) + { + Writer.StrongNameGetPublicKey(assem.KeyContainerName, null, 0, out publicKey, out size); + if (publicKey == IntPtr.Zero) return null; + } + else + return assem.PublicKeyOrToken; + byte[] result = new byte[size]; + byte* ptr = (byte*)publicKey; + for (int i = 0; i < size; i++) result[i] = *ptr++; + return result; + } + catch { } + { + if (assem.KeyBlob != null) + { + Writer.MscorsnStrongNameGetPublicKeyUsing(null, assem.KeyBlob, assem.KeyBlob.Length, out publicKey, out size); + if (publicKey == IntPtr.Zero) return assem.KeyBlob; + } + else if (assem.KeyContainerName != null) + { + Writer.MscorsnStrongNameGetPublicKeyUsing(assem.KeyContainerName, null, 0, out publicKey, out size); + if (publicKey == IntPtr.Zero) return null; + } + else + return assem.PublicKeyOrToken; + byte[] result = new byte[size]; + byte* ptr = (byte*)publicKey; + for (int i = 0; i < size; i++) result[i] = *ptr++; + return result; + } + } + [DllImport("mscoree.dll", EntryPoint = "StrongNameGetPublicKey", + SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, + CallingConvention = CallingConvention.StdCall)] + private static extern bool StrongNameGetPublicKey( + string wszKeyContainer, // [in] desired key container name + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] + byte[] pbKeyBlob, // [in] public/private key blob (optional) + int cbKeyBlob, + [Out] out IntPtr ppbPublicKeyBlob, // [out] public key blob + [Out] out int pcbPublicKeyBlob); + [DllImport("mscorsn.dll", EntryPoint = "StrongNameGetPublicKey", + SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true, + CallingConvention = CallingConvention.StdCall)] + private static extern bool MscorsnStrongNameGetPublicKeyUsing( + string wszKeyContainer, // [in] desired key container name + [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 3)] + byte[] pbKeyBlob, // [in] public/private key blob (optional) + int cbKeyBlob, + [Out] out IntPtr ppbPublicKeyBlob, // [out] public key blob + [Out] out int pcbPublicKeyBlob); + + internal static void WritePE(Stream/*!*/ executable, Stream debugSymbols, Module/*!*/ module) + { + MemoryStream mstream = new MemoryStream(); + Ir2md.WritePE(module, null, new BinaryWriter(mstream)); //TODO: need to write the PDB symbols to the stream + mstream.WriteTo(executable); + } + internal static void WritePE(out byte[] executable, Module/*!*/ module) + { + MemoryStream mstream = new MemoryStream(); + Ir2md.WritePE(module, null, new BinaryWriter(mstream)); + executable = mstream.ToArray(); + } + internal static void WritePE(out byte[] executable, out byte[] debugSymbols, Module/*!*/ module) + { + MemoryStream mstream = new MemoryStream(); + Ir2md.WritePE(module, null, new BinaryWriter(mstream)); + executable = mstream.ToArray(); + debugSymbols = null; + } + internal unsafe static void AddWin32Icon(Module/*!*/ module, string win32IconFilePath) + { + if (module == null || win32IconFilePath == null) { Debug.Assert(false); return; } + using (System.IO.FileStream resStream = File.OpenRead(win32IconFilePath)) + { + Writer.AddWin32Icon(module, resStream); + } + } + internal unsafe static void AddWin32Icon(Module/*!*/ module, Stream win32IconStream) + { + if (module == null || win32IconStream == null) { Debug.Assert(false); return; } + long size = win32IconStream.Length; + if (size > int.MaxValue) throw new System.IO.FileLoadException(); + int n = (int)size; + byte[] buffer = new byte[n]; + win32IconStream.Read(buffer, 0, n); + byte* pb = (byte*)Marshal.AllocHGlobal(n); + for (int i = 0; i < n; i++) pb[i] = buffer[i]; + MemoryCursor cursor = new MemoryCursor(pb, n/*, module*/); + if (module.Win32Resources == null) module.Win32Resources = new Win32ResourceList(); + int reserved = cursor.ReadUInt16(); + if (reserved != 0) throw new NullReferenceException(); + int resourceType = cursor.ReadUInt16(); + if (resourceType != 1) throw new NullReferenceException(); + int imageCount = cursor.ReadUInt16(); + BinaryWriter indexHeap = new BinaryWriter(new MemoryStream()); + indexHeap.Write((ushort)0); //Reserved + indexHeap.Write((ushort)1); //idType + indexHeap.Write((ushort)imageCount); + Win32Resource resource = new Win32Resource(); + for (int i = 0; i < imageCount; i++) + { + resource = new Win32Resource(); + resource.CodePage = 0; + resource.Id = module.Win32Resources.Count + 2; + resource.LanguageId = 0; + resource.Name = null; + resource.TypeId = 3; + resource.TypeName = null; + indexHeap.Write(cursor.ReadByte()); //width + indexHeap.Write(cursor.ReadByte()); //height + indexHeap.Write(cursor.ReadByte()); //color count + indexHeap.Write(cursor.ReadByte()); //reserved + indexHeap.Write(cursor.ReadUInt16()); //planes + indexHeap.Write(cursor.ReadUInt16()); //bit count + int len = cursor.ReadInt32(); + int offset = cursor.ReadInt32(); + indexHeap.Write((int)len); + indexHeap.Write((int)module.Win32Resources.Count + 2); + MemoryCursor c = new MemoryCursor(cursor); + c.Position = offset; + resource.Data = c.ReadBytes(len); + module.Win32Resources.Add(resource); + } + resource.CodePage = 0; + resource.Data = indexHeap.BaseStream.ToArray(); + resource.Id = 0x7f00; + resource.LanguageId = 0; + resource.Name = null; + resource.TypeId = 0xe; + resource.TypeName = null; + module.Win32Resources.Add(resource); + } + internal unsafe static void AddWin32ResourceFileToModule(Module/*!*/ module, string/*!*/ win32ResourceFilePath) + { + if (module == null || win32ResourceFilePath == null) { Debug.Assert(false); return; } + using (System.IO.FileStream resStream = File.OpenRead(win32ResourceFilePath)) + { + Writer.AddWin32ResourceFileToModule(module, resStream); + } + } + internal unsafe static void AddWin32ResourceFileToModule(Module/*!*/ module, Stream/*!*/ win32ResourceStream) + { + if (module == null || win32ResourceStream == null) { Debug.Assert(false); return; } + long size = win32ResourceStream.Length; + if (size > int.MaxValue) throw new System.IO.FileLoadException(); + int n = (int)size; + byte[] buffer = new byte[n]; + win32ResourceStream.Read(buffer, 0, n); + byte* pb = (byte*)Marshal.AllocHGlobal(n); + for (int i = 0; i < n; i++) pb[i] = buffer[i]; + MemoryCursor cursor = new MemoryCursor(pb, n/*, module*/); + if (module.Win32Resources == null) module.Win32Resources = new Win32ResourceList(); + while (cursor.Position < n) + { + Win32Resource resource = new Win32Resource(); + resource.CodePage = 0; //Review: Should this be settable? + int dataSize = cursor.ReadInt32(); + cursor.ReadUInt32(); //headerSize + if (cursor.Int16(0) == -1) + { + cursor.ReadInt16(); + resource.TypeId = cursor.ReadUInt16(); + resource.TypeName = null; + } + else + { + resource.TypeId = 0; + resource.TypeName = cursor.ReadUTF16(); + } + if (cursor.Int16(0) == -1) + { + cursor.ReadInt16(); + resource.Id = cursor.ReadUInt16(); + resource.Name = null; + } + else + { + resource.Id = 0; + resource.Name = cursor.ReadUTF16(); + } + cursor.ReadUInt32(); //dataVersion + cursor.ReadUInt16(); //memoryFlags + resource.LanguageId = cursor.ReadUInt16(); + cursor.ReadUInt32(); //version + cursor.ReadUInt32(); //characteristics + resource.Data = cursor.ReadBytes(dataSize); + if (resource.Data != null) + module.Win32Resources.Add(resource); + } + } + internal static void AddWin32VersionInfo(Module/*!*/ module, CompilerOptions/*!*/ options) + { + if (module == null || options == null) { Debug.Assert(false); return; } + Win32Resource resource = new Win32Resource(); + resource.CodePage = 0; + resource.Id = 1; + resource.LanguageId = 0; + resource.Name = null; + resource.TypeId = 0x10; + resource.TypeName = null; + resource.Data = Writer.FillInVsVersionStructure(module, options); + if (module.Win32Resources == null) module.Win32Resources = new Win32ResourceList(); + module.Win32Resources.Add(resource); + } + private static byte[] FillInVsVersionStructure(Module/*!*/ module, CompilerOptions/*!*/ options) + { + AssemblyNode assembly = module as AssemblyNode; + BinaryWriter data = new BinaryWriter(new MemoryStream(), Encoding.Unicode); + data.Write((ushort)0); //Space for length + data.Write((ushort)0x34); //VS_FIXEDFILEINFO length + data.Write((ushort)0); //Type of data in version resource + data.Write("VS_VERSION_INFO", true); + data.Write((ushort)0); //Padding to 4 byte boundary + // VS_FIXEDFILEINFO starts here + data.Write((uint)0xFEEF04BD); //Signature + data.Write((uint)0x00010000); //Version of VS_FIXEDFILEINFO + Version fileVersion = Writer.ParseVersion(options.TargetInformation.Version, true); + if (fileVersion == null && assembly != null) fileVersion = assembly.Version; + if (fileVersion == null) fileVersion = new Version(); + data.Write((ushort)fileVersion.Minor); + data.Write((ushort)fileVersion.Major); + data.Write((ushort)fileVersion.Revision); + data.Write((ushort)fileVersion.Build); + Version productVersion = Writer.ParseVersion(options.TargetInformation.ProductVersion, true); + if (productVersion == null) productVersion = fileVersion; + data.Write((ushort)productVersion.Minor); + data.Write((ushort)productVersion.Major); + data.Write((ushort)productVersion.Revision); + data.Write((ushort)productVersion.Build); + data.Write((uint)0x3f); //FileFlagsMask + data.Write((uint)0x0); //FileFlags + data.Write((uint)0x4); //OS: Win32 (After all, this is a Win32 resource.) + if (options.GenerateExecutable) + data.Write((uint)1); //App + else + data.Write((uint)2); //Dll + data.Write((uint)0); //File subtype + data.Write((ulong)0); //File Date + // VarFileInfo + data.Write((ushort)0x44); //Length of VarFileInfo + data.Write((ushort)0x0); //Length of value + data.Write((ushort)0x1); //type (text) + data.Write("VarFileInfo", true); + data.Write((ushort)0); //padding to 4 byte boundary + // Var + data.Write((ushort)0x24); //Length of Var + data.Write((ushort)0x04); //length of Value + data.Write((ushort)0); //Type (binary) + data.Write("Translation", true); + data.Write((uint)0); //Padding + data.Write((ushort)0x4b0); //Code Page for Unicode + // StringFileInfo + int positionOfInfoLength = data.BaseStream.Position; + data.Write((ushort)0); //length of rest of resource + data.Write((ushort)0); //Value length, always 0 + data.Write((ushort)1); //Type (text) + data.Write("StringFileInfo", true); + // StringInfo + int stringInfoLengthPos = data.BaseStream.Position; + data.Write((ushort)0); //Space for length + data.Write((ushort)0); //Value length, always 0 + data.Write((ushort)1); //Type (text) + data.Write("000004b0", true); //Code page for Unicode + Writer.WriteVersionString(data, options.TargetInformation.Description, "Comments"); + Writer.WriteVersionString(data, options.TargetInformation.Company, "CompanyName"); + Writer.WriteVersionString(data, options.TargetInformation.Title, "FileDescription"); + Writer.WriteVersionString(data, Writer.ConvertToString(fileVersion), "FileVersion"); + string fileName = module.Name + (options.GenerateExecutable ? ".exe" : ".dll"); + Writer.WriteVersionString(data, fileName, "InternalName"); + Writer.WriteVersionString(data, options.TargetInformation.Copyright, "LegalCopyright"); + Writer.WriteVersionString(data, options.TargetInformation.Trademark, "LegalTrademarks"); + Writer.WriteVersionString(data, fileName, "OriginalFilename"); + Writer.WriteVersionString(data, options.TargetInformation.Product, "ProductName"); + Writer.WriteVersionString(data, Writer.ConvertToString(productVersion), "ProductVersion"); + if (assembly != null) + Writer.WriteVersionString(data, assembly.Version == null ? "" : assembly.Version.ToString(), "Assembly Version"); + int len = data.BaseStream.Position; + data.BaseStream.Position = stringInfoLengthPos; + data.Write((ushort)(len - stringInfoLengthPos)); + data.BaseStream.Position = 0; + data.Write((ushort)len); + data.BaseStream.Position = positionOfInfoLength; + data.Write((ushort)len - positionOfInfoLength); + return data.BaseStream.ToArray(); + } + private static void WriteVersionString(BinaryWriter/*!*/ data, string value, string/*!*/ key) + { + if (value == null) return; + int totalLength = 6; + totalLength += key.Length * 2; + totalLength += 4 - (totalLength % 4); + totalLength += value.Length * 2; + totalLength += 4 - (totalLength % 4); + data.Write((ushort)totalLength); + data.Write((ushort)(value.Length + 1)); + data.Write((ushort)1); //Type (text) + data.Write(key, true); + if (data.BaseStream.Position % 4 != 0) data.Write((char)0); + data.Write(value, true); + if (data.BaseStream.Position % 4 != 0) data.Write((char)0); + } + private static string/*!*/ ConvertToString(Version/*!*/ version) + { + StringBuilder sb = new StringBuilder(); + sb.Append(version.Major.ToString()); + if (version.Minor != 0 || version.Build != 0 || version.Revision != 0) + { + sb.Append('.'); + sb.Append(version.Minor.ToString()); + } + if (version.Build != 0 || version.Revision != 0) + { + sb.Append('.'); + sb.Append(version.Build.ToString()); + } + if (version.Revision != 0) + { + sb.Append('.'); + sb.Append(version.Revision.ToString()); + } + return sb.ToString(); + } + private static Version ParseVersion(string vString, bool allowWildcards) + { + if (vString == null) return null; + ushort major = 1; + ushort minor = 0; + ushort build = 0; + ushort revision = 0; + try + { + int n = vString.Length; + int i = vString.IndexOf('.', 0); + if (i < 0) throw new FormatException(); + major = UInt16.Parse(vString.Substring(0, i), CultureInfo.InvariantCulture); + int j = vString.IndexOf('.', i + 1); + if (j < i + 1) + minor = UInt16.Parse(vString.Substring(i + 1, n - i - 1), CultureInfo.InvariantCulture); + else + { + minor = UInt16.Parse(vString.Substring(i + 1, j - i - 1), CultureInfo.InvariantCulture); + if (vString[j + 1] == '*' && allowWildcards) + { + if (j + 1 < n - 1) return null; + build = Writer.DaysSince2000(); + revision = Writer.SecondsSinceMidnight(); + } + else + { + int k = vString.IndexOf('.', j + 1); + if (k < j + 1) + build = UInt16.Parse(vString.Substring(j + 1, n - j - 1), CultureInfo.InvariantCulture); + else + { + build = UInt16.Parse(vString.Substring(j + 1, k - j - 1), CultureInfo.InvariantCulture); + if (vString[k + 1] == '*' && allowWildcards) + { + if (j + 1 < n - 1) return null; + revision = Writer.SecondsSinceMidnight(); + } + else + revision = UInt16.Parse(vString.Substring(k + 1, n - k - 1), CultureInfo.InvariantCulture); + } + } + } + } + catch (FormatException) + { + major = minor = build = revision = UInt16.MaxValue; + } + catch (OverflowException) + { + major = minor = build = revision = UInt16.MaxValue; + } + if (major == UInt16.MaxValue && minor == UInt16.MaxValue && build == UInt16.MaxValue && revision == UInt16.MaxValue) + { + return null; + } + return new Version(major, minor, build, revision); + } + private static ushort DaysSince2000() + { + return (ushort)(DateTime.Now - new DateTime(2000, 1, 1)).Days; + } + private static ushort SecondsSinceMidnight() + { + TimeSpan sinceMidnight = DateTime.Now - DateTime.Today; + return (ushort)((sinceMidnight.Hours * 60 * 60 + sinceMidnight.Minutes * 60 + sinceMidnight.Seconds) / 2); + } + + } +} +#endif |