summaryrefslogtreecommitdiff
path: root/src/inc/corhdr.h
diff options
context:
space:
mode:
authorJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
committerJiyoung Yun <jy910.yun@samsung.com>2016-11-23 10:09:09 (GMT)
commit4b4aad7217d3292650e77eec2cf4c198ea9c3b4b (patch)
tree98110734c91668dfdbb126fcc0e15ddbd93738ca /src/inc/corhdr.h
parentfa45f57ed55137c75ac870356a1b8f76c84b229c (diff)
downloadcoreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.zip
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.gz
coreclr-4b4aad7217d3292650e77eec2cf4c198ea9c3b4b.tar.bz2
Imported Upstream version 1.1.0upstream/1.1.0
Diffstat (limited to 'src/inc/corhdr.h')
-rw-r--r--src/inc/corhdr.h1930
1 files changed, 1930 insertions, 0 deletions
diff --git a/src/inc/corhdr.h b/src/inc/corhdr.h
new file mode 100644
index 0000000..c194def
--- /dev/null
+++ b/src/inc/corhdr.h
@@ -0,0 +1,1930 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+/*****************************************************************************
+ ** **
+ ** CorHdr.h - contains definitions for the Runtime structures, **
+**
+
+ ** needed to work with metadata. **
+ ** **
+ *****************************************************************************/
+//
+// The top most managed code structure in a EXE or DLL is the IMAGE_COR20_HEADER
+// see code:#ManagedHeader for more
+
+#ifndef __CORHDR_H__
+#define __CORHDR_H__
+
+#define FRAMEWORK_REGISTRY_KEY "Software\\Microsoft\\.NETFramework"
+#define FRAMEWORK_REGISTRY_KEY_W L"Software\\Microsoft\\.NETFramework"
+
+// keys for HKCU
+#ifdef _WIN64
+#define USER_FRAMEWORK_REGISTRY_KEY "Software\\Microsoft\\.NETFramework64"
+#define USER_FRAMEWORK_REGISTRY_KEY_W L"Software\\Microsoft\\.NETFramework64"
+#else
+#define USER_FRAMEWORK_REGISTRY_KEY "Software\\Microsoft\\.NETFramework"
+#define USER_FRAMEWORK_REGISTRY_KEY_W L"Software\\Microsoft\\.NETFramework"
+#endif
+
+
+#ifdef _MSC_VER
+#pragma warning(disable:4200) // nonstandard extension used : zero-sized array in struct/union.
+#endif
+typedef LPVOID mdScope; // Obsolete; not used in the runtime.
+typedef ULONG32 mdToken; // Generic token
+
+
+// Token definitions
+
+
+typedef mdToken mdModule; // Module token (roughly, a scope)
+typedef mdToken mdTypeRef; // TypeRef reference (this or other scope)
+typedef mdToken mdTypeDef; // TypeDef in this scope
+typedef mdToken mdFieldDef; // Field in this scope
+typedef mdToken mdMethodDef; // Method in this scope
+typedef mdToken mdParamDef; // param token
+typedef mdToken mdInterfaceImpl; // interface implementation token
+
+typedef mdToken mdMemberRef; // MemberRef (this or other scope)
+typedef mdToken mdCustomAttribute; // attribute token
+typedef mdToken mdPermission; // DeclSecurity
+
+typedef mdToken mdSignature; // Signature object
+typedef mdToken mdEvent; // event token
+typedef mdToken mdProperty; // property token
+
+typedef mdToken mdModuleRef; // Module reference (for the imported modules)
+
+// Assembly tokens.
+typedef mdToken mdAssembly; // Assembly token.
+typedef mdToken mdAssemblyRef; // AssemblyRef token.
+typedef mdToken mdFile; // File token.
+typedef mdToken mdExportedType; // ExportedType token.
+typedef mdToken mdManifestResource; // ManifestResource token.
+
+typedef mdToken mdTypeSpec; // TypeSpec object
+
+typedef mdToken mdGenericParam; // formal parameter to generic type or method
+typedef mdToken mdMethodSpec; // instantiation of a generic method
+typedef mdToken mdGenericParamConstraint; // constraint on a formal generic parameter
+
+// Application string.
+typedef mdToken mdString; // User literal string token.
+
+typedef mdToken mdCPToken; // constantpool token
+
+#ifndef MACROS_NOT_SUPPORTED
+typedef ULONG RID;
+#else
+typedef unsigned RID;
+#endif // MACROS_NOT_SUPPORTED
+
+typedef enum ReplacesGeneralNumericDefines
+{
+// Directory entry macro for CLR data.
+#ifndef IMAGE_DIRECTORY_ENTRY_COMHEADER
+ IMAGE_DIRECTORY_ENTRY_COMHEADER =14,
+#endif // IMAGE_DIRECTORY_ENTRY_COMHEADER
+} ReplacesGeneralNumericDefines;
+
+
+// The COMIMAGE_FLAGS_32BITREQUIRED and COMIMAGE_FLAGS_32BITPREFERRED flags defined below interact as a pair
+// in order to get the performance profile we desire for platform neutral assemblies while retaining backwards
+// compatibility with pre-4.5 runtimes/OSs, which don't know about COMIMAGE_FLAGS_32BITPREFERRED.
+//
+// COMIMAGE_FLAGS_32BITREQUIRED originally meant "this assembly is x86-only" (required to distinguish platform
+// neutral assemblies which also mark their PE MachineType as IMAGE_FILE_MACHINE_I386).
+//
+// COMIMAGE_FLAGS_32BITPREFERRED has been added so we can create a sub-class of platform neutral assembly that
+// prefers to be loaded into 32-bit environment for perf reasons, but is still compatible with 64-bit
+// environments.
+//
+// In order to retain maximum backwards compatibility you cannot simply read or write one of these flags
+// however. You must treat them as a pair, a two-bit field with the following meanings:
+//
+// 32BITREQUIRED 32BITPREFERRED
+// 0 0 : no special meaning, MachineType and ILONLY flag determine image requirements
+// 0 1 : illegal, reserved for future use
+// 1 0 : image is x86-specific
+// 1 1 : image is platform neutral and prefers to be loaded 32-bit when possible
+//
+// To simplify manipulation of these flags the following macros are provided below.
+
+#define COR_IS_32BIT_REQUIRED(_flags) \
+ (((_flags) & (COMIMAGE_FLAGS_32BITREQUIRED|COMIMAGE_FLAGS_32BITPREFERRED)) == (COMIMAGE_FLAGS_32BITREQUIRED))
+
+#define COR_IS_32BIT_PREFERRED(_flags) \
+ (((_flags) & (COMIMAGE_FLAGS_32BITREQUIRED|COMIMAGE_FLAGS_32BITPREFERRED)) == (COMIMAGE_FLAGS_32BITREQUIRED|COMIMAGE_FLAGS_32BITPREFERRED))
+
+#define COR_SET_32BIT_REQUIRED(_flagsfield) \
+ do { _flagsfield = (_flagsfield & ~COMIMAGE_FLAGS_32BITPREFERRED) | COMIMAGE_FLAGS_32BITREQUIRED; } while (false)
+
+#define COR_SET_32BIT_PREFERRED(_flagsfield) \
+ do { _flagsfield |= COMIMAGE_FLAGS_32BITPREFERRED|COMIMAGE_FLAGS_32BITREQUIRED; } while (false)
+
+#define COR_CLEAR_32BIT_REQUIRED(_flagsfield) \
+ do { _flagsfield &= ~(COMIMAGE_FLAGS_32BITREQUIRED|COMIMAGE_FLAGS_32BITPREFERRED); } while (false)
+
+#define COR_CLEAR_32BIT_PREFERRED(_flagsfield) \
+ do { _flagsfield &= ~(COMIMAGE_FLAGS_32BITREQUIRED|COMIMAGE_FLAGS_32BITPREFERRED); } while (false)
+
+
+#ifndef __IMAGE_COR20_HEADER_DEFINED__
+#define __IMAGE_COR20_HEADER_DEFINED__
+
+typedef enum ReplacesCorHdrNumericDefines
+{
+// COM+ Header entry point flags.
+ COMIMAGE_FLAGS_ILONLY =0x00000001,
+ COMIMAGE_FLAGS_32BITREQUIRED =0x00000002, // *** Do not manipulate this bit directly (see notes above)
+ COMIMAGE_FLAGS_IL_LIBRARY =0x00000004,
+ COMIMAGE_FLAGS_STRONGNAMESIGNED =0x00000008,
+ COMIMAGE_FLAGS_NATIVE_ENTRYPOINT =0x00000010,
+ COMIMAGE_FLAGS_TRACKDEBUGDATA =0x00010000,
+ COMIMAGE_FLAGS_32BITPREFERRED =0x00020000, // *** Do not manipulate this bit directly (see notes above)
+
+
+// Version flags for image.
+ COR_VERSION_MAJOR_V2 =2,
+ COR_VERSION_MAJOR =COR_VERSION_MAJOR_V2,
+ COR_VERSION_MINOR =5,
+ COR_DELETED_NAME_LENGTH =8,
+ COR_VTABLEGAP_NAME_LENGTH =8,
+
+// Maximum size of a NativeType descriptor.
+ NATIVE_TYPE_MAX_CB =1,
+ COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE=0xFF,
+
+// V-table constants
+ COR_VTABLE_32BIT =0x01, // V-table slots are 32-bits in size.
+ COR_VTABLE_64BIT =0x02, // V-table slots are 64-bits in size.
+ COR_VTABLE_FROM_UNMANAGED =0x04, // If set, transition from unmanaged.
+ COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN=0x08, // NEW
+ COR_VTABLE_CALL_MOST_DERIVED =0x10, // Call most derived method described by
+
+// Max name lengths
+ //@todo: Change to unlimited name lengths.
+ MAX_CLASS_NAME =1024,
+ MAX_PACKAGE_NAME =1024,
+} ReplacesCorHdrNumericDefines;
+
+// #ManagedHeader
+//
+// A managed code EXE or DLL uses the same basic format that unmanaged executables use call the Portable
+// Executable (PE) format. See http://en.wikipedia.org/wiki/Portable_Executable or
+// http://msdn.microsoft.com/msdnmag/issues/02/02/PE/default.aspx for more on this format and RVAs.
+//
+// PE files define fixed table of well known entry pointers call Directory entries. Each entry holds the
+// relative virtual address (RVA) and length of a blob of data within the PE file. You can see these using
+// the command
+//
+// link /dump /headers <EXENAME>
+//
+//
+// Managed code has defined one of these entries (the 14th see code:IMAGE_DIRECTORY_ENTRY_COMHEADER) and the RVA points
+// that the IMAGE_COR20_HEADER. This header shows up in the previous dump as the following line
+//
+// // Managed code is identified by is following line
+//
+// 2008 [ 48] RVA [size] of COM Descriptor Directory
+//
+// The IMAGE_COR20_HEADER is mostly just RVA:Length pairs (pointers) to other interesting data structures.
+// The most important of these is the MetaData tables. The easiest way of looking at meta-data is using
+// the IlDasm.exe tool.
+//
+// MetaData holds most of the information in the IL image. THe exceptions are resource blobs and the IL
+// instructions streams for individual methods. Intstead the Meta-data for a method holds an RVA to a
+// code:IMAGE_COR_ILMETHOD which holds all the IL stream (and exception handling information).
+//
+// Precompiled (NGEN) images use the same IMAGE_COR20_HEADER but also use the ManagedNativeHeader field to
+// point at structures that only exist in precompiled images.
+//
+typedef struct IMAGE_COR20_HEADER
+{
+ // Header versioning
+ DWORD cb;
+ WORD MajorRuntimeVersion;
+ WORD MinorRuntimeVersion;
+
+ // Symbol table and startup information
+ IMAGE_DATA_DIRECTORY MetaData;
+ DWORD Flags;
+
+ // The main program if it is an EXE (not used if a DLL?)
+ // If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is not set, EntryPointToken represents a managed entrypoint.
+ // If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is set, EntryPointRVA represents an RVA to a native entrypoint
+ // (depricated for DLLs, use modules constructors intead).
+ union {
+ DWORD EntryPointToken;
+ DWORD EntryPointRVA;
+ };
+
+ // This is the blob of managed resources. Fetched using code:AssemblyNative.GetResource and
+ // code:PEFile.GetResource and accessible from managed code from
+ // System.Assembly.GetManifestResourceStream. The meta data has a table that maps names to offsets into
+ // this blob, so logically the blob is a set of resources.
+ IMAGE_DATA_DIRECTORY Resources;
+ // IL assemblies can be signed with a public-private key to validate who created it. The signature goes
+ // here if this feature is used.
+ IMAGE_DATA_DIRECTORY StrongNameSignature;
+
+ IMAGE_DATA_DIRECTORY CodeManagerTable; // Depricated, not used
+ // Used for manged codee that has unmaanaged code inside it (or exports methods as unmanaged entry points)
+ IMAGE_DATA_DIRECTORY VTableFixups;
+ IMAGE_DATA_DIRECTORY ExportAddressTableJumps;
+
+ // null for ordinary IL images. NGEN images it points at a code:CORCOMPILE_HEADER structure
+ IMAGE_DATA_DIRECTORY ManagedNativeHeader;
+
+} IMAGE_COR20_HEADER, *PIMAGE_COR20_HEADER;
+
+#else // !__IMAGE_COR20_HEADER_DEFINED__
+
+// <TODO>@TODO: This is required because we pull in the COM+ 2.0 PE header
+// definition from WinNT.h, and these constants have not yet propogated to there.</TODO>
+//
+#define COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN 0x08
+#define COMIMAGE_FLAGS_32BITPREFERRED 0x00020000
+
+#endif // __IMAGE_COR20_HEADER_DEFINED__
+
+
+// The most recent version.
+
+#define COR_CTOR_METHOD_NAME ".ctor"
+#define COR_CTOR_METHOD_NAME_W L".ctor"
+#define COR_CCTOR_METHOD_NAME ".cctor"
+#define COR_CCTOR_METHOD_NAME_W L".cctor"
+
+#define COR_ENUM_FIELD_NAME "value__"
+#define COR_ENUM_FIELD_NAME_W L"value__"
+
+// The predefined name for deleting a typeDef,MethodDef, FieldDef, Property and Event
+#define COR_DELETED_NAME_A "_Deleted"
+#define COR_DELETED_NAME_W L"_Deleted"
+#define COR_VTABLEGAP_NAME_A "_VtblGap"
+#define COR_VTABLEGAP_NAME_W L"_VtblGap"
+
+// We intentionally use strncmp so that we will ignore any suffix
+#define IsDeletedName(strName) (strncmp(strName, COR_DELETED_NAME_A, COR_DELETED_NAME_LENGTH) == 0)
+#define IsVtblGapName(strName) (strncmp(strName, COR_VTABLEGAP_NAME_A, COR_VTABLEGAP_NAME_LENGTH) == 0)
+
+// TypeDef/ExportedType attr bits, used by DefineTypeDef.
+typedef enum CorTypeAttr
+{
+ // Use this mask to retrieve the type visibility information.
+ tdVisibilityMask = 0x00000007,
+ tdNotPublic = 0x00000000, // Class is not public scope.
+ tdPublic = 0x00000001, // Class is public scope.
+ tdNestedPublic = 0x00000002, // Class is nested with public visibility.
+ tdNestedPrivate = 0x00000003, // Class is nested with private visibility.
+ tdNestedFamily = 0x00000004, // Class is nested with family visibility.
+ tdNestedAssembly = 0x00000005, // Class is nested with assembly visibility.
+ tdNestedFamANDAssem = 0x00000006, // Class is nested with family and assembly visibility.
+ tdNestedFamORAssem = 0x00000007, // Class is nested with family or assembly visibility.
+
+ // Use this mask to retrieve class layout information
+ tdLayoutMask = 0x00000018,
+ tdAutoLayout = 0x00000000, // Class fields are auto-laid out
+ tdSequentialLayout = 0x00000008, // Class fields are laid out sequentially
+ tdExplicitLayout = 0x00000010, // Layout is supplied explicitly
+ // end layout mask
+
+ // Use this mask to retrieve class semantics information.
+ tdClassSemanticsMask = 0x00000020,
+ tdClass = 0x00000000, // Type is a class.
+ tdInterface = 0x00000020, // Type is an interface.
+ // end semantics mask
+
+ // Special semantics in addition to class semantics.
+ tdAbstract = 0x00000080, // Class is abstract
+ tdSealed = 0x00000100, // Class is concrete and may not be extended
+ tdSpecialName = 0x00000400, // Class name is special. Name describes how.
+
+ // Implementation attributes.
+ tdImport = 0x00001000, // Class / interface is imported
+ tdSerializable = 0x00002000, // The class is Serializable.
+ tdWindowsRuntime = 0x00004000, // The type is a Windows Runtime type
+
+ // Use tdStringFormatMask to retrieve string information for native interop
+ tdStringFormatMask = 0x00030000,
+ tdAnsiClass = 0x00000000, // LPTSTR is interpreted as ANSI in this class
+ tdUnicodeClass = 0x00010000, // LPTSTR is interpreted as UNICODE
+ tdAutoClass = 0x00020000, // LPTSTR is interpreted automatically
+ tdCustomFormatClass = 0x00030000, // A non-standard encoding specified by CustomFormatMask
+ tdCustomFormatMask = 0x00C00000, // Use this mask to retrieve non-standard encoding information for native interop. The meaning of the values of these 2 bits is unspecified.
+
+ // end string format mask
+
+ tdBeforeFieldInit = 0x00100000, // Initialize the class any time before first static field access.
+ tdForwarder = 0x00200000, // This ExportedType is a type forwarder.
+
+ // Flags reserved for runtime use.
+ tdReservedMask = 0x00040800,
+ tdRTSpecialName = 0x00000800, // Runtime should check name encoding.
+ tdHasSecurity = 0x00040000, // Class has security associate with it.
+} CorTypeAttr;
+
+
+// Macros for accessing the members of the CorTypeAttr.
+#define IsTdNotPublic(x) (((x) & tdVisibilityMask) == tdNotPublic)
+#define IsTdPublic(x) (((x) & tdVisibilityMask) == tdPublic)
+#define IsTdNestedPublic(x) (((x) & tdVisibilityMask) == tdNestedPublic)
+#define IsTdNestedPrivate(x) (((x) & tdVisibilityMask) == tdNestedPrivate)
+#define IsTdNestedFamily(x) (((x) & tdVisibilityMask) == tdNestedFamily)
+#define IsTdNestedAssembly(x) (((x) & tdVisibilityMask) == tdNestedAssembly)
+#define IsTdNestedFamANDAssem(x) (((x) & tdVisibilityMask) == tdNestedFamANDAssem)
+#define IsTdNestedFamORAssem(x) (((x) & tdVisibilityMask) == tdNestedFamORAssem)
+#define IsTdNested(x) (((x) & tdVisibilityMask) >= tdNestedPublic)
+
+#define IsTdAutoLayout(x) (((x) & tdLayoutMask) == tdAutoLayout)
+#define IsTdSequentialLayout(x) (((x) & tdLayoutMask) == tdSequentialLayout)
+#define IsTdExplicitLayout(x) (((x) & tdLayoutMask) == tdExplicitLayout)
+
+#define IsTdClass(x) (((x) & tdClassSemanticsMask) == tdClass)
+#define IsTdInterface(x) (((x) & tdClassSemanticsMask) == tdInterface)
+
+#define IsTdAbstract(x) ((x) & tdAbstract)
+#define IsTdSealed(x) ((x) & tdSealed)
+#define IsTdSpecialName(x) ((x) & tdSpecialName)
+
+#define IsTdImport(x) ((x) & tdImport)
+#define IsTdSerializable(x) ((x) & tdSerializable)
+#define IsTdWindowsRuntime(x) ((x) & tdWindowsRuntime)
+
+#define IsTdAnsiClass(x) (((x) & tdStringFormatMask) == tdAnsiClass)
+#define IsTdUnicodeClass(x) (((x) & tdStringFormatMask) == tdUnicodeClass)
+#define IsTdAutoClass(x) (((x) & tdStringFormatMask) == tdAutoClass)
+#define IsTdCustomFormatClass(x) (((x) & tdStringFormatMask) == tdCustomFormatClass)
+#define IsTdBeforeFieldInit(x) ((x) & tdBeforeFieldInit)
+#define IsTdForwarder(x) ((x) & tdForwarder)
+
+#define IsTdRTSpecialName(x) ((x) & tdRTSpecialName)
+#define IsTdHasSecurity(x) ((x) & tdHasSecurity)
+
+// MethodDef attr bits, Used by DefineMethod.
+typedef enum CorMethodAttr
+{
+ // member access mask - Use this mask to retrieve accessibility information.
+ mdMemberAccessMask = 0x0007,
+ mdPrivateScope = 0x0000, // Member not referenceable.
+ mdPrivate = 0x0001, // Accessible only by the parent type.
+ mdFamANDAssem = 0x0002, // Accessible by sub-types only in this Assembly.
+ mdAssem = 0x0003, // Accessibly by anyone in the Assembly.
+ mdFamily = 0x0004, // Accessible only by type and sub-types.
+ mdFamORAssem = 0x0005, // Accessibly by sub-types anywhere, plus anyone in assembly.
+ mdPublic = 0x0006, // Accessibly by anyone who has visibility to this scope.
+ // end member access mask
+
+ // method contract attributes.
+ mdStatic = 0x0010, // Defined on type, else per instance.
+ mdFinal = 0x0020, // Method may not be overridden.
+ mdVirtual = 0x0040, // Method virtual.
+ mdHideBySig = 0x0080, // Method hides by name+sig, else just by name.
+
+ // vtable layout mask - Use this mask to retrieve vtable attributes.
+ mdVtableLayoutMask = 0x0100,
+ mdReuseSlot = 0x0000, // The default.
+ mdNewSlot = 0x0100, // Method always gets a new slot in the vtable.
+ // end vtable layout mask
+
+ // method implementation attributes.
+ mdCheckAccessOnOverride = 0x0200, // Overridability is the same as the visibility.
+ mdAbstract = 0x0400, // Method does not provide an implementation.
+ mdSpecialName = 0x0800, // Method is special. Name describes how.
+
+ // interop attributes
+ mdPinvokeImpl = 0x2000, // Implementation is forwarded through pinvoke.
+ mdUnmanagedExport = 0x0008, // Managed method exported via thunk to unmanaged code.
+
+ // Reserved flags for runtime use only.
+ mdReservedMask = 0xd000,
+ mdRTSpecialName = 0x1000, // Runtime should check name encoding.
+ mdHasSecurity = 0x4000, // Method has security associate with it.
+ mdRequireSecObject = 0x8000, // Method calls another method containing security code.
+
+} CorMethodAttr;
+
+// Macros for accessing the members of CorMethodAttr.
+#define IsMdPrivateScope(x) (((x) & mdMemberAccessMask) == mdPrivateScope)
+#define IsMdPrivate(x) (((x) & mdMemberAccessMask) == mdPrivate)
+#define IsMdFamANDAssem(x) (((x) & mdMemberAccessMask) == mdFamANDAssem)
+#define IsMdAssem(x) (((x) & mdMemberAccessMask) == mdAssem)
+#define IsMdFamily(x) (((x) & mdMemberAccessMask) == mdFamily)
+#define IsMdFamORAssem(x) (((x) & mdMemberAccessMask) == mdFamORAssem)
+#define IsMdPublic(x) (((x) & mdMemberAccessMask) == mdPublic)
+
+#define IsMdStatic(x) ((x) & mdStatic)
+#define IsMdFinal(x) ((x) & mdFinal)
+#define IsMdVirtual(x) ((x) & mdVirtual)
+#define IsMdHideBySig(x) ((x) & mdHideBySig)
+
+#define IsMdReuseSlot(x) (((x) & mdVtableLayoutMask) == mdReuseSlot)
+#define IsMdNewSlot(x) (((x) & mdVtableLayoutMask) == mdNewSlot)
+
+#define IsMdCheckAccessOnOverride(x) ((x) & mdCheckAccessOnOverride)
+#define IsMdAbstract(x) ((x) & mdAbstract)
+#define IsMdSpecialName(x) ((x) & mdSpecialName)
+
+#define IsMdPinvokeImpl(x) ((x) & mdPinvokeImpl)
+#define IsMdUnmanagedExport(x) ((x) & mdUnmanagedExport)
+
+#define IsMdRTSpecialName(x) ((x) & mdRTSpecialName)
+#define IsMdInstanceInitializer(x, str) (((x) & mdRTSpecialName) && !strcmp((str), COR_CTOR_METHOD_NAME))
+#define IsMdInstanceInitializerW(x, str) (((x) & mdRTSpecialName) && !wcscmp((str), COR_CTOR_METHOD_NAME_W))
+#define IsMdClassConstructor(x, str) (((x) & mdRTSpecialName) && !strcmp((str), COR_CCTOR_METHOD_NAME))
+#define IsMdClassConstructorW(x, str) (((x) & mdRTSpecialName) && !wcscmp((str), COR_CCTOR_METHOD_NAME_W))
+#define IsMdHasSecurity(x) ((x) & mdHasSecurity)
+#define IsMdRequireSecObject(x) ((x) & mdRequireSecObject)
+
+// FieldDef attr bits, used by DefineField.
+typedef enum CorFieldAttr
+{
+ // member access mask - Use this mask to retrieve accessibility information.
+ fdFieldAccessMask = 0x0007,
+ fdPrivateScope = 0x0000, // Member not referenceable.
+ fdPrivate = 0x0001, // Accessible only by the parent type.
+ fdFamANDAssem = 0x0002, // Accessible by sub-types only in this Assembly.
+ fdAssembly = 0x0003, // Accessibly by anyone in the Assembly.
+ fdFamily = 0x0004, // Accessible only by type and sub-types.
+ fdFamORAssem = 0x0005, // Accessibly by sub-types anywhere, plus anyone in assembly.
+ fdPublic = 0x0006, // Accessibly by anyone who has visibility to this scope.
+ // end member access mask
+
+ // field contract attributes.
+ fdStatic = 0x0010, // Defined on type, else per instance.
+ fdInitOnly = 0x0020, // Field may only be initialized, not written to after init.
+ fdLiteral = 0x0040, // Value is compile time constant.
+ fdNotSerialized = 0x0080, // Field does not have to be serialized when type is remoted.
+
+ fdSpecialName = 0x0200, // field is special. Name describes how.
+
+ // interop attributes
+ fdPinvokeImpl = 0x2000, // Implementation is forwarded through pinvoke.
+
+ // Reserved flags for runtime use only.
+ fdReservedMask = 0x9500,
+ fdRTSpecialName = 0x0400, // Runtime(metadata internal APIs) should check name encoding.
+ fdHasFieldMarshal = 0x1000, // Field has marshalling information.
+ fdHasDefault = 0x8000, // Field has default.
+ fdHasFieldRVA = 0x0100, // Field has RVA.
+} CorFieldAttr;
+
+// Macros for accessing the members of CorFieldAttr.
+#define IsFdPrivateScope(x) (((x) & fdFieldAccessMask) == fdPrivateScope)
+#define IsFdPrivate(x) (((x) & fdFieldAccessMask) == fdPrivate)
+#define IsFdFamANDAssem(x) (((x) & fdFieldAccessMask) == fdFamANDAssem)
+#define IsFdAssembly(x) (((x) & fdFieldAccessMask) == fdAssembly)
+#define IsFdFamily(x) (((x) & fdFieldAccessMask) == fdFamily)
+#define IsFdFamORAssem(x) (((x) & fdFieldAccessMask) == fdFamORAssem)
+#define IsFdPublic(x) (((x) & fdFieldAccessMask) == fdPublic)
+
+#define IsFdStatic(x) ((x) & fdStatic)
+#define IsFdInitOnly(x) ((x) & fdInitOnly)
+#define IsFdLiteral(x) ((x) & fdLiteral)
+#define IsFdNotSerialized(x) ((x) & fdNotSerialized)
+
+#define IsFdPinvokeImpl(x) ((x) & fdPinvokeImpl)
+#define IsFdSpecialName(x) ((x) & fdSpecialName)
+#define IsFdHasFieldRVA(x) ((x) & fdHasFieldRVA)
+
+#define IsFdRTSpecialName(x) ((x) & fdRTSpecialName)
+#define IsFdHasFieldMarshal(x) ((x) & fdHasFieldMarshal)
+#define IsFdHasDefault(x) ((x) & fdHasDefault)
+
+// Param attr bits, used by DefineParam.
+typedef enum CorParamAttr
+{
+ pdIn = 0x0001, // Param is [In]
+ pdOut = 0x0002, // Param is [out]
+ pdOptional = 0x0010, // Param is optional
+
+ // Reserved flags for Runtime use only.
+ pdReservedMask = 0xf000,
+ pdHasDefault = 0x1000, // Param has default value.
+ pdHasFieldMarshal = 0x2000, // Param has FieldMarshal.
+
+ pdUnused = 0xcfe0,
+} CorParamAttr;
+
+// Macros for accessing the members of CorParamAttr.
+#define IsPdIn(x) ((x) & pdIn)
+#define IsPdOut(x) ((x) & pdOut)
+#define IsPdOptional(x) ((x) & pdOptional)
+
+#define IsPdHasDefault(x) ((x) & pdHasDefault)
+#define IsPdHasFieldMarshal(x) ((x) & pdHasFieldMarshal)
+
+
+// Property attr bits, used by DefineProperty.
+typedef enum CorPropertyAttr
+{
+ prSpecialName = 0x0200, // property is special. Name describes how.
+
+ // Reserved flags for Runtime use only.
+ prReservedMask = 0xf400,
+ prRTSpecialName = 0x0400, // Runtime(metadata internal APIs) should check name encoding.
+ prHasDefault = 0x1000, // Property has default
+
+ prUnused = 0xe9ff,
+} CorPropertyAttr;
+
+// Macros for accessing the members of CorPropertyAttr.
+#define IsPrSpecialName(x) ((x) & prSpecialName)
+
+#define IsPrRTSpecialName(x) ((x) & prRTSpecialName)
+#define IsPrHasDefault(x) ((x) & prHasDefault)
+
+// Event attr bits, used by DefineEvent.
+typedef enum CorEventAttr
+{
+ evSpecialName = 0x0200, // event is special. Name describes how.
+
+ // Reserved flags for Runtime use only.
+ evReservedMask = 0x0400,
+ evRTSpecialName = 0x0400, // Runtime(metadata internal APIs) should check name encoding.
+} CorEventAttr;
+
+// Macros for accessing the members of CorEventAttr.
+#define IsEvSpecialName(x) ((x) & evSpecialName)
+
+#define IsEvRTSpecialName(x) ((x) & evRTSpecialName)
+
+
+// MethodSemantic attr bits, used by DefineProperty, DefineEvent.
+typedef enum CorMethodSemanticsAttr
+{
+ msSetter = 0x0001, // Setter for property
+ msGetter = 0x0002, // Getter for property
+ msOther = 0x0004, // other method for property or event
+ msAddOn = 0x0008, // AddOn method for event
+ msRemoveOn = 0x0010, // RemoveOn method for event
+ msFire = 0x0020, // Fire method for event
+} CorMethodSemanticsAttr;
+
+// Macros for accessing the members of CorMethodSemanticsAttr.
+#define IsMsSetter(x) ((x) & msSetter)
+#define IsMsGetter(x) ((x) & msGetter)
+#define IsMsOther(x) ((x) & msOther)
+#define IsMsAddOn(x) ((x) & msAddOn)
+#define IsMsRemoveOn(x) ((x) & msRemoveOn)
+#define IsMsFire(x) ((x) & msFire)
+
+
+// DeclSecurity attr bits, used by DefinePermissionSet.
+typedef enum CorDeclSecurity
+{
+ dclActionMask = 0x001f, // Mask allows growth of enum.
+ dclActionNil = 0x0000, //
+ dclRequest = 0x0001, //
+ dclDemand = 0x0002, //
+ dclAssert = 0x0003, //
+ dclDeny = 0x0004, //
+ dclPermitOnly = 0x0005, //
+ dclLinktimeCheck = 0x0006, //
+ dclInheritanceCheck = 0x0007, //
+ dclRequestMinimum = 0x0008, //
+ dclRequestOptional = 0x0009, //
+ dclRequestRefuse = 0x000a, //
+ dclPrejitGrant = 0x000b, // Persisted grant set at prejit time
+ dclPrejitDenied = 0x000c, // Persisted denied set at prejit time
+ dclNonCasDemand = 0x000d, //
+ dclNonCasLinkDemand = 0x000e, //
+ dclNonCasInheritance = 0x000f, //
+ dclMaximumValue = 0x000f, // Maximum legal value
+} CorDeclSecurity;
+
+// Macros for accessing the members of CorDeclSecurity.
+#define IsDclActionNil(x) (((x) & dclActionMask) == dclActionNil)
+
+// Is this a demand that can trigger a stackwalk?
+#define IsDclActionAnyStackModifier(x) ((((x) & dclActionMask) == dclAssert) || \
+ (((x) & dclActionMask) == dclDeny) || \
+ (((x) & dclActionMask) == dclPermitOnly))
+
+// Is this an assembly level attribute (i.e. not applicable on Type/Member)?
+#define IsAssemblyDclAction(x) (((x) >= dclRequestMinimum) && \
+ ((x) <= dclRequestRefuse))
+
+// Is this an NGen only attribute?
+#define IsNGenOnlyDclAction(x) (((x) == dclPrejitGrant) || \
+ ((x) == dclPrejitDenied))
+
+
+// MethodImpl attr bits, used by DefineMethodImpl.
+typedef enum CorMethodImpl
+{
+ // code impl mask
+ miCodeTypeMask = 0x0003, // Flags about code type.
+ miIL = 0x0000, // Method impl is IL.
+ miNative = 0x0001, // Method impl is native.
+ miOPTIL = 0x0002, // Method impl is OPTIL
+ miRuntime = 0x0003, // Method impl is provided by the runtime.
+ // end code impl mask
+
+ // managed mask
+ miManagedMask = 0x0004, // Flags specifying whether the code is managed or unmanaged.
+ miUnmanaged = 0x0004, // Method impl is unmanaged, otherwise managed.
+ miManaged = 0x0000, // Method impl is managed.
+ // end managed mask
+
+ // implementation info and interop
+ miForwardRef = 0x0010, // Indicates method is defined; used primarily in merge scenarios.
+ miPreserveSig = 0x0080, // Indicates method sig is not to be mangled to do HRESULT conversion.
+
+ miInternalCall = 0x1000, // Reserved for internal use.
+
+ miSynchronized = 0x0020, // Method is single threaded through the body.
+ miNoInlining = 0x0008, // Method may not be inlined.
+ miAggressiveInlining = 0x0100, // Method should be inlined if possible.
+ miNoOptimization = 0x0040, // Method may not be optimized.
+
+ // These are the flags that are allowed in MethodImplAttribute's Value
+ // property. This should include everything above except the code impl
+ // flags (which are used for MethodImplAttribute's MethodCodeType field).
+ miUserMask = miManagedMask | miForwardRef | miPreserveSig |
+ miInternalCall | miSynchronized |
+ miNoInlining | miAggressiveInlining |
+ miNoOptimization,
+
+ miMaxMethodImplVal = 0xffff, // Range check value
+} CorMethodImpl;
+
+// Macros for accesing the members of CorMethodImpl.
+#define IsMiIL(x) (((x) & miCodeTypeMask) == miIL)
+#define IsMiNative(x) (((x) & miCodeTypeMask) == miNative)
+#define IsMiOPTIL(x) (((x) & miCodeTypeMask) == miOPTIL)
+#define IsMiRuntime(x) (((x) & miCodeTypeMask) == miRuntime)
+
+#define IsMiUnmanaged(x) (((x) & miManagedMask) == miUnmanaged)
+#define IsMiManaged(x) (((x) & miManagedMask) == miManaged)
+
+#define IsMiForwardRef(x) ((x) & miForwardRef)
+#define IsMiPreserveSig(x) ((x) & miPreserveSig)
+
+#define IsMiInternalCall(x) ((x) & miInternalCall)
+
+#define IsMiSynchronized(x) ((x) & miSynchronized)
+#define IsMiNoInlining(x) ((x) & miNoInlining)
+#define IsMiAggressiveInlining(x) ((x) & miAggressiveInlining)
+#define IsMiNoOptimization(x) ((x) & miNoOptimization)
+
+// PinvokeMap attr bits, used by DefinePinvokeMap.
+typedef enum CorPinvokeMap
+{
+ pmNoMangle = 0x0001, // Pinvoke is to use the member name as specified.
+
+ // Use this mask to retrieve the CharSet information.
+ pmCharSetMask = 0x0006,
+ pmCharSetNotSpec = 0x0000,
+ pmCharSetAnsi = 0x0002,
+ pmCharSetUnicode = 0x0004,
+ pmCharSetAuto = 0x0006,
+
+
+ pmBestFitUseAssem = 0x0000,
+ pmBestFitEnabled = 0x0010,
+ pmBestFitDisabled = 0x0020,
+ pmBestFitMask = 0x0030,
+
+ pmThrowOnUnmappableCharUseAssem = 0x0000,
+ pmThrowOnUnmappableCharEnabled = 0x1000,
+ pmThrowOnUnmappableCharDisabled = 0x2000,
+ pmThrowOnUnmappableCharMask = 0x3000,
+
+ pmSupportsLastError = 0x0040, // Information about target function. Not relevant for fields.
+
+ // None of the calling convention flags is relevant for fields.
+ pmCallConvMask = 0x0700,
+ pmCallConvWinapi = 0x0100, // Pinvoke will use native callconv appropriate to target windows platform.
+ pmCallConvCdecl = 0x0200,
+ pmCallConvStdcall = 0x0300,
+ pmCallConvThiscall = 0x0400, // In M9, pinvoke will raise exception.
+ pmCallConvFastcall = 0x0500,
+
+ pmMaxValue = 0xFFFF,
+} CorPinvokeMap;
+
+// Macros for accessing the members of CorPinvokeMap
+#define IsPmNoMangle(x) ((x) & pmNoMangle)
+
+#define IsPmCharSetNotSpec(x) (((x) & pmCharSetMask) == pmCharSetNotSpec)
+#define IsPmCharSetAnsi(x) (((x) & pmCharSetMask) == pmCharSetAnsi)
+#define IsPmCharSetUnicode(x) (((x) & pmCharSetMask) == pmCharSetUnicode)
+#define IsPmCharSetAuto(x) (((x) & pmCharSetMask) == pmCharSetAuto)
+
+#define IsPmSupportsLastError(x) ((x) & pmSupportsLastError)
+
+#define IsPmCallConvWinapi(x) (((x) & pmCallConvMask) == pmCallConvWinapi)
+#define IsPmCallConvCdecl(x) (((x) & pmCallConvMask) == pmCallConvCdecl)
+#define IsPmCallConvStdcall(x) (((x) & pmCallConvMask) == pmCallConvStdcall)
+#define IsPmCallConvThiscall(x) (((x) & pmCallConvMask) == pmCallConvThiscall)
+#define IsPmCallConvFastcall(x) (((x) & pmCallConvMask) == pmCallConvFastcall)
+
+#define IsPmBestFitEnabled(x) (((x) & pmBestFitMask) == pmBestFitEnabled)
+#define IsPmBestFitDisabled(x) (((x) & pmBestFitMask) == pmBestFitDisabled)
+#define IsPmBestFitUseAssem(x) (((x) & pmBestFitMask) == pmBestFitUseAssem)
+
+#define IsPmThrowOnUnmappableCharEnabled(x) (((x) & pmThrowOnUnmappableCharMask) == pmThrowOnUnmappableCharEnabled)
+#define IsPmThrowOnUnmappableCharDisabled(x) (((x) & pmThrowOnUnmappableCharMask) == pmThrowOnUnmappableCharDisabled)
+#define IsPmThrowOnUnmappableCharUseAssem(x) (((x) & pmThrowOnUnmappableCharMask) == pmThrowOnUnmappableCharUseAssem)
+
+// Assembly attr bits, used by DefineAssembly.
+typedef enum CorAssemblyFlags
+{
+ afPublicKey = 0x0001, // The assembly ref holds the full (unhashed) public key.
+
+ afPA_None = 0x0000, // Processor Architecture unspecified
+ afPA_MSIL = 0x0010, // Processor Architecture: neutral (PE32)
+ afPA_x86 = 0x0020, // Processor Architecture: x86 (PE32)
+ afPA_IA64 = 0x0030, // Processor Architecture: Itanium (PE32+)
+ afPA_AMD64 = 0x0040, // Processor Architecture: AMD X64 (PE32+)
+ afPA_ARM = 0x0050, // Processor Architecture: ARM (PE32)
+ afPA_NoPlatform = 0x0070, // applies to any platform but cannot run on any (e.g. reference assembly), should not have "specified" set
+ afPA_Specified = 0x0080, // Propagate PA flags to AssemblyRef record
+ afPA_Mask = 0x0070, // Bits describing the processor architecture
+ afPA_FullMask = 0x00F0, // Bits describing the PA incl. Specified
+ afPA_Shift = 0x0004, // NOT A FLAG, shift count in PA flags <--> index conversion
+
+ afEnableJITcompileTracking = 0x8000, // From "DebuggableAttribute".
+ afDisableJITcompileOptimizer = 0x4000, // From "DebuggableAttribute".
+
+ afRetargetable = 0x0100, // The assembly can be retargeted (at runtime) to an
+ // assembly from a different publisher.
+
+ afContentType_Default = 0x0000,
+ afContentType_WindowsRuntime = 0x0200,
+ afContentType_Mask = 0x0E00, // Bits describing ContentType
+} CorAssemblyFlags;
+
+// Macros for accessing the members of CorAssemblyFlags.
+#define IsAfRetargetable(x) ((x) & afRetargetable)
+#define IsAfContentType_Default(x) (((x) & afContentType_Mask) == afContentType_Default)
+#define IsAfContentType_WindowsRuntime(x) (((x) & afContentType_Mask) == afContentType_WindowsRuntime)
+
+// Macros for accessing the Processor Architecture flags of CorAssemblyFlags.
+#define IsAfPA_MSIL(x) (((x) & afPA_Mask) == afPA_MSIL)
+#define IsAfPA_x86(x) (((x) & afPA_Mask) == afPA_x86)
+#define IsAfPA_IA64(x) (((x) & afPA_Mask) == afPA_IA64)
+#define IsAfPA_AMD64(x) (((x) & afPA_Mask) == afPA_AMD64)
+#define IsAfPA_ARM(x) (((x) & afPA_Mask) == afPA_ARM)
+#define IsAfPA_NoPlatform(x) (((x) & afPA_FullMask) == afPA_NoPlatform)
+#define IsAfPA_Specified(x) ((x) & afPA_Specified)
+#define PAIndex(x) (((x) & afPA_Mask) >> afPA_Shift)
+#define PAFlag(x) (((x) << afPA_Shift) & afPA_Mask)
+#define PrepareForSaving(x) ((x) & (((x) & afPA_Specified) ? ~afPA_Specified : ~afPA_FullMask))
+
+#define IsAfEnableJITcompileTracking(x) ((x) & afEnableJITcompileTracking)
+#define IsAfDisableJITcompileOptimizer(x) ((x) & afDisableJITcompileOptimizer)
+
+// Macros for accessing the public key flags of CorAssemblyFlags.
+#define IsAfPublicKey(x) ((x) & afPublicKey)
+#define IsAfPublicKeyToken(x) (((x) & afPublicKey) == 0)
+
+
+// ManifestResource attr bits, used by DefineManifestResource.
+typedef enum CorManifestResourceFlags
+{
+ mrVisibilityMask = 0x0007,
+ mrPublic = 0x0001, // The Resource is exported from the Assembly.
+ mrPrivate = 0x0002, // The Resource is private to the Assembly.
+} CorManifestResourceFlags;
+
+// Macros for accessing the members of CorManifestResourceFlags.
+#define IsMrPublic(x) (((x) & mrVisibilityMask) == mrPublic)
+#define IsMrPrivate(x) (((x) & mrVisibilityMask) == mrPrivate)
+
+
+// File attr bits, used by DefineFile.
+typedef enum CorFileFlags
+{
+ ffContainsMetaData = 0x0000, // This is not a resource file
+ ffContainsNoMetaData = 0x0001, // This is a resource file or other non-metadata-containing file
+} CorFileFlags;
+
+// Macros for accessing the members of CorFileFlags.
+#define IsFfContainsMetaData(x) (!((x) & ffContainsNoMetaData))
+#define IsFfContainsNoMetaData(x) ((x) & ffContainsNoMetaData)
+
+// PE file kind bits, returned by IMetaDataImport2::GetPEKind()
+typedef enum CorPEKind
+{
+ peNot = 0x00000000, // not a PE file
+ peILonly = 0x00000001, // flag IL_ONLY is set in COR header
+ pe32BitRequired=0x00000002, // flag 32BITREQUIRED is set and 32BITPREFERRED is clear in COR header
+ pe32Plus = 0x00000004, // PE32+ file (64 bit)
+ pe32Unmanaged=0x00000008, // PE32 without COR header
+ pe32BitPreferred=0x00000010 // flags 32BITREQUIRED and 32BITPREFERRED are set in COR header
+} CorPEKind;
+
+
+// GenericParam bits, used by DefineGenericParam.
+typedef enum CorGenericParamAttr
+{
+ // Variance of type parameters, only applicable to generic parameters
+ // for generic interfaces and delegates
+ gpVarianceMask = 0x0003,
+ gpNonVariant = 0x0000,
+ gpCovariant = 0x0001,
+ gpContravariant = 0x0002,
+
+ // Special constraints, applicable to any type parameters
+ gpSpecialConstraintMask = 0x001C,
+ gpNoSpecialConstraint = 0x0000,
+ gpReferenceTypeConstraint = 0x0004, // type argument must be a reference type
+ gpNotNullableValueTypeConstraint = 0x0008, // type argument must be a value type but not Nullable
+ gpDefaultConstructorConstraint = 0x0010, // type argument must have a public default constructor
+} CorGenericParamAttr;
+
+// structures and enums moved from COR.H
+typedef unsigned __int8 COR_SIGNATURE;
+
+typedef COR_SIGNATURE* PCOR_SIGNATURE; // pointer to a cor sig. Not void* so that
+ // the bytes can be incremented easily
+typedef const COR_SIGNATURE* PCCOR_SIGNATURE;
+
+
+typedef const char * MDUTF8CSTR;
+typedef char * MDUTF8STR;
+
+//*****************************************************************************
+//
+// Element type for Cor signature
+//
+//*****************************************************************************
+
+typedef enum CorElementType
+{
+ ELEMENT_TYPE_END = 0x00,
+ ELEMENT_TYPE_VOID = 0x01,
+ ELEMENT_TYPE_BOOLEAN = 0x02,
+ ELEMENT_TYPE_CHAR = 0x03,
+ ELEMENT_TYPE_I1 = 0x04,
+ ELEMENT_TYPE_U1 = 0x05,
+ ELEMENT_TYPE_I2 = 0x06,
+ ELEMENT_TYPE_U2 = 0x07,
+ ELEMENT_TYPE_I4 = 0x08,
+ ELEMENT_TYPE_U4 = 0x09,
+ ELEMENT_TYPE_I8 = 0x0a,
+ ELEMENT_TYPE_U8 = 0x0b,
+ ELEMENT_TYPE_R4 = 0x0c,
+ ELEMENT_TYPE_R8 = 0x0d,
+ ELEMENT_TYPE_STRING = 0x0e,
+
+ // every type above PTR will be simple type
+ ELEMENT_TYPE_PTR = 0x0f, // PTR <type>
+ ELEMENT_TYPE_BYREF = 0x10, // BYREF <type>
+
+ // Please use ELEMENT_TYPE_VALUETYPE. ELEMENT_TYPE_VALUECLASS is deprecated.
+ ELEMENT_TYPE_VALUETYPE = 0x11, // VALUETYPE <class Token>
+ ELEMENT_TYPE_CLASS = 0x12, // CLASS <class Token>
+ ELEMENT_TYPE_VAR = 0x13, // a class type variable VAR <number>
+ ELEMENT_TYPE_ARRAY = 0x14, // MDARRAY <type> <rank> <bcount> <bound1> ... <lbcount> <lb1> ...
+ ELEMENT_TYPE_GENERICINST = 0x15, // GENERICINST <generic type> <argCnt> <arg1> ... <argn>
+ ELEMENT_TYPE_TYPEDBYREF = 0x16, // TYPEDREF (it takes no args) a typed referece to some other type
+
+ ELEMENT_TYPE_I = 0x18, // native integer size
+ ELEMENT_TYPE_U = 0x19, // native unsigned integer size
+ ELEMENT_TYPE_FNPTR = 0x1b, // FNPTR <complete sig for the function including calling convention>
+ ELEMENT_TYPE_OBJECT = 0x1c, // Shortcut for System.Object
+ ELEMENT_TYPE_SZARRAY = 0x1d, // Shortcut for single dimension zero lower bound array
+ // SZARRAY <type>
+ ELEMENT_TYPE_MVAR = 0x1e, // a method type variable MVAR <number>
+
+ // This is only for binding
+ ELEMENT_TYPE_CMOD_REQD = 0x1f, // required C modifier : E_T_CMOD_REQD <mdTypeRef/mdTypeDef>
+ ELEMENT_TYPE_CMOD_OPT = 0x20, // optional C modifier : E_T_CMOD_OPT <mdTypeRef/mdTypeDef>
+
+ // This is for signatures generated internally (which will not be persisted in any way).
+ ELEMENT_TYPE_INTERNAL = 0x21, // INTERNAL <typehandle>
+
+ // Note that this is the max of base type excluding modifiers
+ ELEMENT_TYPE_MAX = 0x22, // first invalid element type
+
+
+ ELEMENT_TYPE_MODIFIER = 0x40,
+ ELEMENT_TYPE_SENTINEL = 0x01 | ELEMENT_TYPE_MODIFIER, // sentinel for varargs
+ ELEMENT_TYPE_PINNED = 0x05 | ELEMENT_TYPE_MODIFIER,
+
+} CorElementType;
+
+
+//*****************************************************************************
+//
+// Serialization types for Custom attribute support
+//
+//*****************************************************************************
+
+typedef enum CorSerializationType
+{
+ SERIALIZATION_TYPE_UNDEFINED = 0,
+ SERIALIZATION_TYPE_BOOLEAN = ELEMENT_TYPE_BOOLEAN,
+ SERIALIZATION_TYPE_CHAR = ELEMENT_TYPE_CHAR,
+ SERIALIZATION_TYPE_I1 = ELEMENT_TYPE_I1,
+ SERIALIZATION_TYPE_U1 = ELEMENT_TYPE_U1,
+ SERIALIZATION_TYPE_I2 = ELEMENT_TYPE_I2,
+ SERIALIZATION_TYPE_U2 = ELEMENT_TYPE_U2,
+ SERIALIZATION_TYPE_I4 = ELEMENT_TYPE_I4,
+ SERIALIZATION_TYPE_U4 = ELEMENT_TYPE_U4,
+ SERIALIZATION_TYPE_I8 = ELEMENT_TYPE_I8,
+ SERIALIZATION_TYPE_U8 = ELEMENT_TYPE_U8,
+ SERIALIZATION_TYPE_R4 = ELEMENT_TYPE_R4,
+ SERIALIZATION_TYPE_R8 = ELEMENT_TYPE_R8,
+ SERIALIZATION_TYPE_STRING = ELEMENT_TYPE_STRING,
+ SERIALIZATION_TYPE_SZARRAY = ELEMENT_TYPE_SZARRAY, // Shortcut for single dimension zero lower bound array
+ SERIALIZATION_TYPE_TYPE = 0x50,
+ SERIALIZATION_TYPE_TAGGED_OBJECT= 0x51,
+ SERIALIZATION_TYPE_FIELD = 0x53,
+ SERIALIZATION_TYPE_PROPERTY = 0x54,
+ SERIALIZATION_TYPE_ENUM = 0x55
+} CorSerializationType;
+
+//
+// Calling convention flags.
+//
+
+
+typedef enum CorCallingConvention
+{
+ IMAGE_CEE_CS_CALLCONV_DEFAULT = 0x0,
+
+ IMAGE_CEE_CS_CALLCONV_VARARG = 0x5,
+ IMAGE_CEE_CS_CALLCONV_FIELD = 0x6,
+ IMAGE_CEE_CS_CALLCONV_LOCAL_SIG = 0x7,
+ IMAGE_CEE_CS_CALLCONV_PROPERTY = 0x8,
+ IMAGE_CEE_CS_CALLCONV_UNMGD = 0x9,
+ IMAGE_CEE_CS_CALLCONV_GENERICINST = 0xa, // generic method instantiation
+ IMAGE_CEE_CS_CALLCONV_NATIVEVARARG = 0xb, // used ONLY for 64bit vararg PInvoke calls
+ IMAGE_CEE_CS_CALLCONV_MAX = 0xc, // first invalid calling convention
+
+
+ // The high bits of the calling convention convey additional info
+ IMAGE_CEE_CS_CALLCONV_MASK = 0x0f, // Calling convention is bottom 4 bits
+ IMAGE_CEE_CS_CALLCONV_HASTHIS = 0x20, // Top bit indicates a 'this' parameter
+ IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS = 0x40, // This parameter is explicitly in the signature
+ IMAGE_CEE_CS_CALLCONV_GENERIC = 0x10, // Generic method sig with explicit number of type arguments (precedes ordinary parameter count)
+ // 0x80 is reserved for internal use
+} CorCallingConvention;
+
+#define IMAGE_CEE_CS_CALLCONV_INSTANTIATION IMAGE_CEE_CS_CALLCONV_GENERICINST
+
+typedef enum CorUnmanagedCallingConvention
+{
+ IMAGE_CEE_UNMANAGED_CALLCONV_C = 0x1,
+ IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL = 0x2,
+ IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL = 0x3,
+ IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL = 0x4,
+
+ IMAGE_CEE_CS_CALLCONV_C = IMAGE_CEE_UNMANAGED_CALLCONV_C,
+ IMAGE_CEE_CS_CALLCONV_STDCALL = IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL,
+ IMAGE_CEE_CS_CALLCONV_THISCALL = IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL,
+ IMAGE_CEE_CS_CALLCONV_FASTCALL = IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL,
+
+} CorUnmanagedCallingConvention;
+
+
+typedef enum CorArgType
+{
+ IMAGE_CEE_CS_END = 0x0,
+ IMAGE_CEE_CS_VOID = 0x1,
+ IMAGE_CEE_CS_I4 = 0x2,
+ IMAGE_CEE_CS_I8 = 0x3,
+ IMAGE_CEE_CS_R4 = 0x4,
+ IMAGE_CEE_CS_R8 = 0x5,
+ IMAGE_CEE_CS_PTR = 0x6,
+ IMAGE_CEE_CS_OBJECT = 0x7,
+ IMAGE_CEE_CS_STRUCT4 = 0x8,
+ IMAGE_CEE_CS_STRUCT32 = 0x9,
+ IMAGE_CEE_CS_BYVALUE = 0xA,
+} CorArgType;
+
+
+//*****************************************************************************
+//
+// Native type for N-Direct
+//
+//*****************************************************************************
+
+typedef enum CorNativeType
+{
+
+ // Kepp this in-synch with ndp\clr\src\BCL\System\runtime\interopservices\attributes.cs
+
+ NATIVE_TYPE_END = 0x0, //DEPRECATED
+ NATIVE_TYPE_VOID = 0x1, //DEPRECATED
+ NATIVE_TYPE_BOOLEAN = 0x2, // (4 byte boolean value: TRUE = non-zero, FALSE = 0)
+ NATIVE_TYPE_I1 = 0x3,
+ NATIVE_TYPE_U1 = 0x4,
+ NATIVE_TYPE_I2 = 0x5,
+ NATIVE_TYPE_U2 = 0x6,
+ NATIVE_TYPE_I4 = 0x7,
+ NATIVE_TYPE_U4 = 0x8,
+ NATIVE_TYPE_I8 = 0x9,
+ NATIVE_TYPE_U8 = 0xa,
+ NATIVE_TYPE_R4 = 0xb,
+ NATIVE_TYPE_R8 = 0xc,
+ NATIVE_TYPE_SYSCHAR = 0xd, //DEPRECATED
+ NATIVE_TYPE_VARIANT = 0xe, //DEPRECATED
+ NATIVE_TYPE_CURRENCY = 0xf,
+ NATIVE_TYPE_PTR = 0x10, //DEPRECATED
+
+ NATIVE_TYPE_DECIMAL = 0x11, //DEPRECATED
+ NATIVE_TYPE_DATE = 0x12, //DEPRECATED
+ NATIVE_TYPE_BSTR = 0x13, //COMINTEROP
+ NATIVE_TYPE_LPSTR = 0x14,
+ NATIVE_TYPE_LPWSTR = 0x15,
+ NATIVE_TYPE_LPTSTR = 0x16,
+ NATIVE_TYPE_FIXEDSYSSTRING = 0x17,
+ NATIVE_TYPE_OBJECTREF = 0x18, //DEPRECATED
+ NATIVE_TYPE_IUNKNOWN = 0x19, //COMINTEROP
+ NATIVE_TYPE_IDISPATCH = 0x1a, //COMINTEROP
+ NATIVE_TYPE_STRUCT = 0x1b,
+ NATIVE_TYPE_INTF = 0x1c, //COMINTEROP
+ NATIVE_TYPE_SAFEARRAY = 0x1d, //COMINTEROP
+ NATIVE_TYPE_FIXEDARRAY = 0x1e,
+ NATIVE_TYPE_INT = 0x1f,
+ NATIVE_TYPE_UINT = 0x20,
+
+ NATIVE_TYPE_NESTEDSTRUCT = 0x21, //DEPRECATED (use NATIVE_TYPE_STRUCT)
+
+ NATIVE_TYPE_BYVALSTR = 0x22, //COMINTEROP
+
+ NATIVE_TYPE_ANSIBSTR = 0x23, //COMINTEROP
+
+ NATIVE_TYPE_TBSTR = 0x24, // select BSTR or ANSIBSTR depending on platform
+ //COMINTEROP
+
+ NATIVE_TYPE_VARIANTBOOL = 0x25, // (2-byte boolean value: TRUE = -1, FALSE = 0)
+ //COMINTEROP
+ NATIVE_TYPE_FUNC = 0x26,
+
+ NATIVE_TYPE_ASANY = 0x28,
+
+ NATIVE_TYPE_ARRAY = 0x2a,
+ NATIVE_TYPE_LPSTRUCT = 0x2b,
+
+ NATIVE_TYPE_CUSTOMMARSHALER = 0x2c, // Custom marshaler native type. This must be followed
+ // by a string of the following format:
+ // "Native type name/0Custom marshaler type name/0Optional cookie/0"
+ // Or
+ // "{Native type GUID}/0Custom marshaler type name/0Optional cookie/0"
+
+ NATIVE_TYPE_ERROR = 0x2d, // This native type coupled with ELEMENT_TYPE_I4 will map to VT_HRESULT
+ //COMINTEROP
+
+ NATIVE_TYPE_IINSPECTABLE = 0x2e,
+ NATIVE_TYPE_HSTRING = 0x2f,
+ NATIVE_TYPE_LPUTF8STR = 0x30, // utf-8 string
+ NATIVE_TYPE_MAX = 0x50, // first invalid element type
+} CorNativeType;
+
+
+enum
+{
+ DESCR_GROUP_METHODDEF = 0, // DESCR group for MethodDefs
+ DESCR_GROUP_METHODIMPL, // DESCR group for MethodImpls
+};
+
+/***********************************************************************************/
+// a COR_ILMETHOD_SECT is a generic container for attributes that are private
+// to a particular method. The COR_ILMETHOD structure points to one of these
+// (see GetSect()). COR_ILMETHOD_SECT can decode the Kind of attribute (but not
+// its internal data layout, and can skip past the current attibute to find the
+// Next one. The overhead for COR_ILMETHOD_SECT is a minimum of 2 bytes.
+
+typedef enum CorILMethodSect // codes that identify attributes
+{
+ CorILMethod_Sect_Reserved = 0,
+ CorILMethod_Sect_EHTable = 1,
+ CorILMethod_Sect_OptILTable = 2,
+
+ CorILMethod_Sect_KindMask = 0x3F, // The mask for decoding the type code
+ CorILMethod_Sect_FatFormat = 0x40, // fat format
+ CorILMethod_Sect_MoreSects = 0x80, // there is another attribute after this one
+} CorILMethodSect;
+
+/************************************/
+/* NOTE this structure must be DWORD aligned!! */
+
+typedef struct IMAGE_COR_ILMETHOD_SECT_SMALL
+{
+ BYTE Kind;
+ BYTE DataSize;
+
+} IMAGE_COR_ILMETHOD_SECT_SMALL;
+
+
+
+/************************************/
+/* NOTE this structure must be DWORD aligned!! */
+typedef struct IMAGE_COR_ILMETHOD_SECT_FAT
+{
+ unsigned Kind : 8;
+ unsigned DataSize : 24;
+
+} IMAGE_COR_ILMETHOD_SECT_FAT;
+
+
+
+/***********************************************************************************/
+/* If COR_ILMETHOD_SECT_HEADER::Kind() = CorILMethod_Sect_EHTable then the attribute
+ is a list of exception handling clauses. There are two formats, fat or small
+*/
+typedef enum CorExceptionFlag // definitions for the Flags field below (for both big and small)
+{
+ COR_ILEXCEPTION_CLAUSE_NONE, // This is a typed handler
+ COR_ILEXCEPTION_CLAUSE_OFFSETLEN = 0x0000, // Deprecated
+ COR_ILEXCEPTION_CLAUSE_DEPRECATED = 0x0000, // Deprecated
+ COR_ILEXCEPTION_CLAUSE_FILTER = 0x0001, // If this bit is on, then this EH entry is for a filter
+ COR_ILEXCEPTION_CLAUSE_FINALLY = 0x0002, // This clause is a finally clause
+ COR_ILEXCEPTION_CLAUSE_FAULT = 0x0004, // Fault clause (finally that is called on exception only)
+ COR_ILEXCEPTION_CLAUSE_DUPLICATED = 0x0008, // duplicated clause. This clause was duplicated to a funclet which was pulled out of line
+} CorExceptionFlag;
+
+/***********************************/
+typedef struct IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT
+{
+ CorExceptionFlag Flags;
+ DWORD TryOffset;
+ DWORD TryLength; // relative to start of try block
+ DWORD HandlerOffset;
+ DWORD HandlerLength; // relative to start of handler
+ union {
+ DWORD ClassToken; // use for type-based exception handlers
+ DWORD FilterOffset; // use for filter-based exception handlers (COR_ILEXCEPTION_FILTER is set)
+ };
+} IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT;
+
+typedef struct IMAGE_COR_ILMETHOD_SECT_EH_FAT
+{
+ IMAGE_COR_ILMETHOD_SECT_FAT SectFat;
+ IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_FAT Clauses[1]; // actually variable size
+} IMAGE_COR_ILMETHOD_SECT_EH_FAT;
+
+/***********************************/
+typedef struct IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_SMALL
+{
+#ifdef _WIN64
+ unsigned Flags : 16;
+#else // !_WIN64
+ CorExceptionFlag Flags : 16;
+#endif
+ unsigned TryOffset : 16;
+ unsigned TryLength : 8; // relative to start of try block
+ unsigned HandlerOffset : 16;
+ unsigned HandlerLength : 8; // relative to start of handler
+ union {
+ DWORD ClassToken;
+ DWORD FilterOffset;
+ };
+} IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_SMALL;
+
+/***********************************/
+typedef struct IMAGE_COR_ILMETHOD_SECT_EH_SMALL
+{
+ IMAGE_COR_ILMETHOD_SECT_SMALL SectSmall;
+ WORD Reserved;
+ IMAGE_COR_ILMETHOD_SECT_EH_CLAUSE_SMALL Clauses[1]; // actually variable size
+} IMAGE_COR_ILMETHOD_SECT_EH_SMALL;
+
+
+
+typedef union IMAGE_COR_ILMETHOD_SECT_EH
+{
+ IMAGE_COR_ILMETHOD_SECT_EH_SMALL Small;
+ IMAGE_COR_ILMETHOD_SECT_EH_FAT Fat;
+} IMAGE_COR_ILMETHOD_SECT_EH;
+
+
+/***********************************************************************************/
+// Legal values for
+// * code:IMAGE_COR_ILMETHOD_FAT::Flags or
+// * code:IMAGE_COR_ILMETHOD_TINY::Flags_CodeSize fields.
+//
+// The only semantic flag at present is CorILMethod_InitLocals
+typedef enum CorILMethodFlags
+{
+ CorILMethod_InitLocals = 0x0010, // call default constructor on all local vars
+ CorILMethod_MoreSects = 0x0008, // there is another attribute after this one
+
+ CorILMethod_CompressedIL = 0x0040, // Not used.
+
+ // Indicates the format for the COR_ILMETHOD header
+ CorILMethod_FormatShift = 3,
+ CorILMethod_FormatMask = ((1 << CorILMethod_FormatShift) - 1),
+ CorILMethod_TinyFormat = 0x0002, // use this code if the code size is even
+ CorILMethod_SmallFormat = 0x0000,
+ CorILMethod_FatFormat = 0x0003,
+ CorILMethod_TinyFormat1 = 0x0006, // use this code if the code size is odd
+} CorILMethodFlags;
+
+/***************************************************************************/
+/* Used when the method is tiny (< 64 bytes), and there are no local vars */
+typedef struct IMAGE_COR_ILMETHOD_TINY
+{
+ BYTE Flags_CodeSize;
+} IMAGE_COR_ILMETHOD_TINY;
+
+/************************************/
+// This strucuture is the 'fat' layout, where no compression is attempted.
+// Note that this structure can be added on at the end, thus making it extensible
+typedef struct IMAGE_COR_ILMETHOD_FAT
+{
+ unsigned Flags : 12; // Flags see code:CorILMethodFlags
+ unsigned Size : 4; // size in DWords of this structure (currently 3)
+ unsigned MaxStack : 16; // maximum number of items (I4, I, I8, obj ...), on the operand stack
+ DWORD CodeSize; // size of the code
+ mdSignature LocalVarSigTok; // token that indicates the signature of the local vars (0 means none)
+
+} IMAGE_COR_ILMETHOD_FAT;
+
+// an IMAGE_COR_ILMETHOD holds the IL instructions for a individual method. To save space they come in two
+// flavors Fat and Tiny. Conceptually Tiny is just a compressed version of Fat, so code:IMAGE_COR_ILMETHOD_FAT
+// is the logical structure for all headers. Conceptually this blob holds the IL, the Exception Handling
+// Tables, the local variable information and some flags.
+typedef union IMAGE_COR_ILMETHOD
+{
+ IMAGE_COR_ILMETHOD_TINY Tiny;
+ IMAGE_COR_ILMETHOD_FAT Fat;
+} IMAGE_COR_ILMETHOD;
+
+//*****************************************************************************
+// Non VOS v-table entries. Define an array of these pointed to by
+// IMAGE_COR20_HEADER.VTableFixups. Each entry describes a contiguous array of
+// v-table slots. The slots start out initialized to the meta data token value
+// for the method they need to call. At image load time, the CLR Loader will
+// turn each entry into a pointer to machine code for the CPU and can be
+// called directly.
+//*****************************************************************************
+
+typedef struct IMAGE_COR_VTABLEFIXUP
+{
+ ULONG RVA; // Offset of v-table array in image.
+ USHORT Count; // How many entries at location.
+ USHORT Type; // COR_VTABLE_xxx type of entries.
+} IMAGE_COR_VTABLEFIXUP;
+
+
+
+
+
+//*****************************************************************************
+//*****************************************************************************
+//
+// M E T A - D A T A D E C L A R A T I O N S
+//
+//*****************************************************************************
+//*****************************************************************************
+
+//*****************************************************************************
+//
+// Enums for SetOption API.
+//
+//*****************************************************************************
+
+// flags for MetaDataCheckDuplicatesFor
+typedef enum CorCheckDuplicatesFor
+{
+ MDDupAll = 0xffffffff,
+ MDDupENC = MDDupAll,
+ MDNoDupChecks = 0x00000000,
+ MDDupTypeDef = 0x00000001,
+ MDDupInterfaceImpl = 0x00000002,
+ MDDupMethodDef = 0x00000004,
+ MDDupTypeRef = 0x00000008,
+ MDDupMemberRef = 0x00000010,
+ MDDupCustomAttribute = 0x00000020,
+ MDDupParamDef = 0x00000040,
+ MDDupPermission = 0x00000080,
+ MDDupProperty = 0x00000100,
+ MDDupEvent = 0x00000200,
+ MDDupFieldDef = 0x00000400,
+ MDDupSignature = 0x00000800,
+ MDDupModuleRef = 0x00001000,
+ MDDupTypeSpec = 0x00002000,
+ MDDupImplMap = 0x00004000,
+ MDDupAssemblyRef = 0x00008000,
+ MDDupFile = 0x00010000,
+ MDDupExportedType = 0x00020000,
+ MDDupManifestResource = 0x00040000,
+ MDDupGenericParam = 0x00080000,
+ MDDupMethodSpec = 0x00100000,
+ MDDupGenericParamConstraint = 0x00200000,
+ // gap for debug junk
+ MDDupAssembly = 0x10000000,
+
+ // This is the default behavior on metadata. It will check duplicates for TypeRef, MemberRef, Signature, TypeSpec and MethodSpec.
+ MDDupDefault = MDNoDupChecks | MDDupTypeRef | MDDupMemberRef | MDDupSignature | MDDupTypeSpec | MDDupMethodSpec,
+} CorCheckDuplicatesFor;
+
+// flags for MetaDataRefToDefCheck
+typedef enum CorRefToDefCheck
+{
+ // default behavior is to always perform TypeRef to TypeDef and MemberRef to MethodDef/FieldDef optimization
+ MDRefToDefDefault = 0x00000003,
+ MDRefToDefAll = 0xffffffff,
+ MDRefToDefNone = 0x00000000,
+ MDTypeRefToDef = 0x00000001,
+ MDMemberRefToDef = 0x00000002
+} CorRefToDefCheck;
+
+
+// MetaDataNotificationForTokenMovement
+typedef enum CorNotificationForTokenMovement
+{
+ // default behavior is to notify TypeRef, MethodDef, MemberRef, and FieldDef token remaps
+ MDNotifyDefault = 0x0000000f,
+ MDNotifyAll = 0xffffffff,
+ MDNotifyNone = 0x00000000,
+ MDNotifyMethodDef = 0x00000001,
+ MDNotifyMemberRef = 0x00000002,
+ MDNotifyFieldDef = 0x00000004,
+ MDNotifyTypeRef = 0x00000008,
+
+ MDNotifyTypeDef = 0x00000010,
+ MDNotifyParamDef = 0x00000020,
+ MDNotifyInterfaceImpl = 0x00000040,
+ MDNotifyProperty = 0x00000080,
+ MDNotifyEvent = 0x00000100,
+ MDNotifySignature = 0x00000200,
+ MDNotifyTypeSpec = 0x00000400,
+ MDNotifyCustomAttribute = 0x00000800,
+ MDNotifySecurityValue = 0x00001000,
+ MDNotifyPermission = 0x00002000,
+ MDNotifyModuleRef = 0x00004000,
+
+ MDNotifyNameSpace = 0x00008000,
+
+ MDNotifyAssemblyRef = 0x01000000,
+ MDNotifyFile = 0x02000000,
+ MDNotifyExportedType = 0x04000000,
+ MDNotifyResource = 0x08000000,
+} CorNotificationForTokenMovement;
+
+
+typedef enum CorSetENC
+{
+ MDSetENCOn = 0x00000001, // Deprecated name.
+ MDSetENCOff = 0x00000002, // Deprecated name.
+
+ MDUpdateENC = 0x00000001, // ENC mode. Tokens don't move; can be updated.
+ MDUpdateFull = 0x00000002, // "Normal" update mode.
+ MDUpdateExtension = 0x00000003, // Extension mode. Tokens don't move, adds only.
+ MDUpdateIncremental = 0x00000004, // Incremental compilation
+ MDUpdateDelta = 0x00000005, // If ENC on, save only deltas.
+ MDUpdateMask = 0x00000007,
+
+
+} CorSetENC;
+
+#define IsENCDelta(x) (((x) & MDUpdateMask) == MDUpdateDelta)
+
+// flags used in SetOption when pair with MetaDataErrorIfEmitOutOfOrder guid
+typedef enum CorErrorIfEmitOutOfOrder
+{
+ MDErrorOutOfOrderDefault = 0x00000000, // default not to generate any error
+ MDErrorOutOfOrderNone = 0x00000000, // do not generate error for out of order emit
+ MDErrorOutOfOrderAll = 0xffffffff, // generate out of order emit for method, field, param, property, and event
+ MDMethodOutOfOrder = 0x00000001, // generate error when methods are emitted out of order
+ MDFieldOutOfOrder = 0x00000002, // generate error when fields are emitted out of order
+ MDParamOutOfOrder = 0x00000004, // generate error when params are emitted out of order
+ MDPropertyOutOfOrder = 0x00000008, // generate error when properties are emitted out of order
+ MDEventOutOfOrder = 0x00000010, // generate error when events are emitted out of order
+} CorErrorIfEmitOutOfOrder;
+
+
+// flags used in SetOption when pair with MetaDataImportOption guid
+typedef enum CorImportOptions
+{
+ MDImportOptionDefault = 0x00000000, // default to skip over deleted records
+ MDImportOptionAll = 0xFFFFFFFF, // Enumerate everything
+ MDImportOptionAllTypeDefs = 0x00000001, // all of the typedefs including the deleted typedef
+ MDImportOptionAllMethodDefs = 0x00000002, // all of the methoddefs including the deleted ones
+ MDImportOptionAllFieldDefs = 0x00000004, // all of the fielddefs including the deleted ones
+ MDImportOptionAllProperties = 0x00000008, // all of the properties including the deleted ones
+ MDImportOptionAllEvents = 0x00000010, // all of the events including the deleted ones
+ MDImportOptionAllCustomAttributes = 0x00000020, // all of the custom attributes including the deleted ones
+ MDImportOptionAllExportedTypes = 0x00000040, // all of the ExportedTypes including the deleted ones
+
+} CorImportOptions;
+
+
+// flags for MetaDataThreadSafetyOptions
+typedef enum CorThreadSafetyOptions
+{
+ // default behavior is to have thread safety turn off. This means that MetaData APIs will not take reader/writer
+ // lock. Clients is responsible to make sure the properly thread synchornization when using MetaData APIs.
+ MDThreadSafetyDefault = 0x00000000,
+ MDThreadSafetyOff = 0x00000000,
+ MDThreadSafetyOn = 0x00000001,
+} CorThreadSafetyOptions;
+
+
+// flags for MetaDataLinkerOptions
+typedef enum CorLinkerOptions
+{
+ // default behavior is not to keep private types
+ MDAssembly = 0x00000000,
+ MDNetModule = 0x00000001,
+} CorLinkerOptions;
+
+// flags for MetaDataMergeOptions
+typedef enum MergeFlags
+{
+ MergeFlagsNone = 0,
+ MergeManifest = 0x00000001,
+ DropMemberRefCAs = 0x00000002,
+ NoDupCheck = 0x00000004,
+ MergeExportedTypes = 0x00000008
+} MergeFlags;
+
+// flags for MetaDataPreserveLocalRefs
+typedef enum CorLocalRefPreservation
+{
+ MDPreserveLocalRefsNone = 0x00000000,
+ MDPreserveLocalTypeRef = 0x00000001,
+ MDPreserveLocalMemberRef = 0x00000002
+} CorLocalRefPreservation;
+
+//
+// struct used to retrieve field offset
+// used by GetClassLayout and SetClassLayout
+//
+
+#ifndef _COR_FIELD_OFFSET_
+#define _COR_FIELD_OFFSET_
+
+typedef struct COR_FIELD_OFFSET
+{
+ mdFieldDef ridOfField;
+ ULONG ulOffset;
+} COR_FIELD_OFFSET;
+
+#endif
+
+
+//
+// Token tags.
+//
+typedef enum CorTokenType
+{
+ mdtModule = 0x00000000, //
+ mdtTypeRef = 0x01000000, //
+ mdtTypeDef = 0x02000000, //
+ mdtFieldDef = 0x04000000, //
+ mdtMethodDef = 0x06000000, //
+ mdtParamDef = 0x08000000, //
+ mdtInterfaceImpl = 0x09000000, //
+ mdtMemberRef = 0x0a000000, //
+ mdtCustomAttribute = 0x0c000000, //
+ mdtPermission = 0x0e000000, //
+ mdtSignature = 0x11000000, //
+ mdtEvent = 0x14000000, //
+ mdtProperty = 0x17000000, //
+ mdtMethodImpl = 0x19000000, //
+ mdtModuleRef = 0x1a000000, //
+ mdtTypeSpec = 0x1b000000, //
+ mdtAssembly = 0x20000000, //
+ mdtAssemblyRef = 0x23000000, //
+ mdtFile = 0x26000000, //
+ mdtExportedType = 0x27000000, //
+ mdtManifestResource = 0x28000000, //
+ mdtGenericParam = 0x2a000000, //
+ mdtMethodSpec = 0x2b000000, //
+ mdtGenericParamConstraint = 0x2c000000,
+
+ mdtString = 0x70000000, //
+ mdtName = 0x71000000, //
+ mdtBaseType = 0x72000000, // Leave this on the high end value. This does not correspond to metadata table
+} CorTokenType;
+
+//
+// Build / decompose tokens.
+//
+#define RidToToken(rid,tktype) ((rid) |= (tktype))
+#define TokenFromRid(rid,tktype) ((rid) | (tktype))
+#define RidFromToken(tk) ((RID) ((tk) & 0x00ffffff))
+#define TypeFromToken(tk) ((ULONG32)((tk) & 0xff000000))
+#define IsNilToken(tk) ((RidFromToken(tk)) == 0)
+
+//
+// Nil tokens
+//
+#define mdTokenNil ((mdToken)0)
+#define mdModuleNil ((mdModule)mdtModule)
+#define mdTypeRefNil ((mdTypeRef)mdtTypeRef)
+#define mdTypeDefNil ((mdTypeDef)mdtTypeDef)
+#define mdFieldDefNil ((mdFieldDef)mdtFieldDef)
+#define mdMethodDefNil ((mdMethodDef)mdtMethodDef)
+#define mdParamDefNil ((mdParamDef)mdtParamDef)
+#define mdInterfaceImplNil ((mdInterfaceImpl)mdtInterfaceImpl)
+#define mdMemberRefNil ((mdMemberRef)mdtMemberRef)
+#define mdCustomAttributeNil ((mdCustomAttribute)mdtCustomAttribute)
+#define mdPermissionNil ((mdPermission)mdtPermission)
+#define mdSignatureNil ((mdSignature)mdtSignature)
+#define mdEventNil ((mdEvent)mdtEvent)
+#define mdPropertyNil ((mdProperty)mdtProperty)
+#define mdModuleRefNil ((mdModuleRef)mdtModuleRef)
+#define mdTypeSpecNil ((mdTypeSpec)mdtTypeSpec)
+#define mdAssemblyNil ((mdAssembly)mdtAssembly)
+#define mdAssemblyRefNil ((mdAssemblyRef)mdtAssemblyRef)
+#define mdFileNil ((mdFile)mdtFile)
+#define mdExportedTypeNil ((mdExportedType)mdtExportedType)
+#define mdManifestResourceNil ((mdManifestResource)mdtManifestResource)
+
+#define mdGenericParamNil ((mdGenericParam)mdtGenericParam)
+#define mdGenericParamConstraintNil ((mdGenericParamConstraint)mdtGenericParamConstraint)
+#define mdMethodSpecNil ((mdMethodSpec)mdtMethodSpec)
+
+#define mdStringNil ((mdString)mdtString)
+
+//
+// Open bits.
+//
+typedef enum CorOpenFlags
+{
+ ofRead = 0x00000000, // Open scope for read
+ ofWrite = 0x00000001, // Open scope for write.
+ ofReadWriteMask = 0x00000001, // Mask for read/write bit.
+
+ ofCopyMemory = 0x00000002, // Open scope with memory. Ask metadata to maintain its own copy of memory.
+
+ ofReadOnly = 0x00000010, // Open scope for read. Will be unable to QI for a IMetadataEmit* interface
+ ofTakeOwnership = 0x00000020, // The memory was allocated with CoTaskMemAlloc and will be freed by the metadata
+
+ // These are obsolete and are ignored.
+ // ofCacheImage = 0x00000004, // EE maps but does not do relocations or verify image
+ // ofManifestMetadata = 0x00000008, // Open scope on ngen image, return the manifest metadata instead of the IL metadata
+ ofNoTypeLib = 0x00000080, // Don't OpenScope on a typelib.
+ ofNoTransform = 0x00001000, // Disable automatic transforms of .winmd files.
+
+ // Internal bits
+ ofReserved1 = 0x00000100, // Reserved for internal use.
+ ofReserved2 = 0x00000200, // Reserved for internal use.
+ ofReserved3 = 0x00000400, // Reserved for internal use.
+ ofReserved = 0xffffef40 // All the reserved bits.
+
+} CorOpenFlags;
+
+#define IsOfRead(x) (((x) & ofReadWriteMask) == ofRead)
+#define IsOfReadWrite(x) (((x) & ofReadWriteMask) == ofWrite)
+
+#define IsOfCopyMemory(x) ((x) & ofCopyMemory)
+
+#define IsOfReadOnly(x) ((x) & ofReadOnly)
+#define IsOfTakeOwnership(x) ((x) & ofTakeOwnership)
+
+#define IsOfReserved(x) (((x) & ofReserved) != 0)
+
+//
+// Type of file mapping returned by code:IMetaDataInfo::GetFileMapping.
+//
+typedef enum CorFileMapping
+{
+ fmFlat = 0, // Flat file mapping - file is mapped as data file (code:SEC_IMAGE flag was not
+ // passed to code:CreateFileMapping).
+ fmExecutableImage = 1, // Executable image file mapping - file is mapped for execution
+ // (either via code:LoadLibrary or code:CreateFileMapping with code:SEC_IMAGE flag).
+} CorFileMapping;
+
+
+typedef CorTypeAttr CorRegTypeAttr;
+
+//
+// Opaque type for an enumeration handle.
+//
+typedef void *HCORENUM;
+
+
+// Note that this must be kept in sync with System.AttributeTargets.
+typedef enum CorAttributeTargets
+{
+ catAssembly = 0x0001,
+ catModule = 0x0002,
+ catClass = 0x0004,
+ catStruct = 0x0008,
+ catEnum = 0x0010,
+ catConstructor = 0x0020,
+ catMethod = 0x0040,
+ catProperty = 0x0080,
+ catField = 0x0100,
+ catEvent = 0x0200,
+ catInterface = 0x0400,
+ catParameter = 0x0800,
+ catDelegate = 0x1000,
+ catGenericParameter = 0x4000,
+
+ catAll = catAssembly | catModule | catClass | catStruct | catEnum | catConstructor |
+ catMethod | catProperty | catField | catEvent | catInterface | catParameter | catDelegate | catGenericParameter,
+ catClassMembers = catClass | catStruct | catEnum | catConstructor | catMethod | catProperty | catField | catEvent | catDelegate | catInterface,
+
+} CorAttributeTargets;
+
+#ifndef MACROS_NOT_SUPPORTED
+//
+// Some well-known custom attributes
+//
+#ifndef IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS
+ #define IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS (IMAGE_CEE_CS_CALLCONV_DEFAULT | IMAGE_CEE_CS_CALLCONV_HASTHIS)
+#endif
+
+#define INTEROP_DISPID_TYPE_W L"System.Runtime.InteropServices.DispIdAttribute"
+#define INTEROP_DISPID_TYPE "System.Runtime.InteropServices.DispIdAttribute"
+#define INTEROP_DISPID_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I4}
+
+#define INTEROP_INTERFACETYPE_TYPE_W L"System.Runtime.InteropServices.InterfaceTypeAttribute"
+#define INTEROP_INTERFACETYPE_TYPE "System.Runtime.InteropServices.InterfaceTypeAttribute"
+#define INTEROP_INTERFACETYPE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_CLASSINTERFACE_TYPE_W L"System.Runtime.InteropServices.ClassInterfaceAttribute"
+#define INTEROP_CLASSINTERFACE_TYPE "System.Runtime.InteropServices.ClassInterfaceAttribute"
+#define INTEROP_CLASSINTERFACE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_COMVISIBLE_TYPE_W L"System.Runtime.InteropServices.ComVisibleAttribute"
+#define INTEROP_COMVISIBLE_TYPE "System.Runtime.InteropServices.ComVisibleAttribute"
+#define INTEROP_COMVISIBLE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_BOOLEAN}
+
+#define INTEROP_COMREGISTERFUNCTION_TYPE_W L"System.Runtime.InteropServices.ComRegisterFunctionAttribute"
+#define INTEROP_COMREGISTERFUNCTION_TYPE "System.Runtime.InteropServices.ComRegisterFunctionAttribute"
+#define INTEROP_COMREGISTERFUNCTION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_COMUNREGISTERFUNCTION_TYPE_W L"System.Runtime.InteropServices.ComUnregisterFunctionAttribute"
+#define INTEROP_COMUNREGISTERFUNCTION_TYPE "System.Runtime.InteropServices.ComUnregisterFunctionAttribute"
+#define INTEROP_COMUNREGISTERFUNCTION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_IMPORTEDFROMTYPELIB_TYPE_W L"System.Runtime.InteropServices.ImportedFromTypeLibAttribute"
+#define INTEROP_IMPORTEDFROMTYPELIB_TYPE "System.Runtime.InteropServices.ImportedFromTypeLibAttribute"
+#define INTEROP_IMPORTEDFROMTYPELIB_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_PRIMARYINTEROPASSEMBLY_TYPE_W L"System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute"
+#define INTEROP_PRIMARYINTEROPASSEMBLY_TYPE "System.Runtime.InteropServices.PrimaryInteropAssemblyAttribute"
+#define INTEROP_PRIMARYINTEROPASSEMBLY_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 2, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I4, ELEMENT_TYPE_I4}
+
+#define INTEROP_IDISPATCHIMPL_TYPE_W L"System.Runtime.InteropServices.IDispatchImplAttribute"
+#define INTEROP_IDISPATCHIMPL_TYPE "System.Runtime.InteropServices.IDispatchImplAttribute"
+#define INTEROP_IDISPATCHIMPL_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_COMSOURCEINTERFACES_TYPE_W L"System.Runtime.InteropServices.ComSourceInterfacesAttribute"
+#define INTEROP_COMSOURCEINTERFACES_TYPE "System.Runtime.InteropServices.ComSourceInterfacesAttribute"
+#define INTEROP_COMSOURCEINTERFACES_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_COMDEFAULTINTERFACE_TYPE_W L"System.Runtime.InteropServices.ComDefaultInterfaceAttribute"
+#define INTEROP_COMDEFAULTINTERFACE_TYPE "System.Runtime.InteropServices.ComDefaultInterfaceAttribute"
+
+#define INTEROP_COMCONVERSIONLOSS_TYPE_W L"System.Runtime.InteropServices.ComConversionLossAttribute"
+#define INTEROP_COMCONVERSIONLOSS_TYPE "System.Runtime.InteropServices.ComConversionLossAttribute"
+#define INTEROP_COMCONVERSIONLOSS_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_BESTFITMAPPING_TYPE_W L"System.Runtime.InteropServices.BestFitMappingAttribute"
+#define INTEROP_BESTFITMAPPING_TYPE "System.Runtime.InteropServices.BestFitMappingAttribute"
+#define INTEROP_BESTFITMAPPING_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 2, ELEMENT_TYPE_VOID, ELEMENT_TYPE_BOOLEAN, ELEMENT_TYPE_BOOLEAN}
+
+#define INTEROP_TYPELIBTYPE_TYPE_W L"System.Runtime.InteropServices.TypeLibTypeAttribute"
+#define INTEROP_TYPELIBTYPE_TYPE "System.Runtime.InteropServices.TypeLibTypeAttribute"
+#define INTEROP_TYPELIBTYPE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_TYPELIBFUNC_TYPE_W L"System.Runtime.InteropServices.TypeLibFuncAttribute"
+#define INTEROP_TYPELIBFUNC_TYPE "System.Runtime.InteropServices.TypeLibFuncAttribute"
+#define INTEROP_TYPELIBFUNC_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_TYPELIBVAR_TYPE_W L"System.Runtime.InteropServices.TypeLibVarAttribute"
+#define INTEROP_TYPELIBVAR_TYPE "System.Runtime.InteropServices.TypeLibVarAttribute"
+#define INTEROP_TYPELIBVAR_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_MARSHALAS_TYPE_W L"System.Runtime.InteropServices.MarshalAsAttribute"
+#define INTEROP_MARSHALAS_TYPE "System.Runtime.InteropServices.MarshalAsAttribute"
+#define INTEROP_MARSHALAS_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2}
+
+#define INTEROP_COMIMPORT_TYPE_W L"System.Runtime.InteropServices.ComImportAttribute"
+#define INTEROP_COMIMPORT_TYPE "System.Runtime.InteropServices.ComImportAttribute"
+#define INTEROP_COMIMPORT_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_GUID_TYPE_W W("System.Runtime.InteropServices.GuidAttribute")
+#define INTEROP_GUID_TYPE "System.Runtime.InteropServices.GuidAttribute"
+#define INTEROP_GUID_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_DEFAULTMEMBER_TYPE_W L"System.Reflection.DefaultMemberAttribute"
+#define INTEROP_DEFAULTMEMBER_TYPE "System.Reflection.DefaultMemberAttribute"
+#define INTEROP_DEFAULTMEMBER_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_COMEMULATE_TYPE_W L"System.Runtime.InteropServices.ComEmulateAttribute"
+#define INTEROP_COMEMULATE_TYPE "System.Runtime.InteropServices.ComEmulateAttribute"
+#define INTEROP_COMEMULATE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_PRESERVESIG_TYPE_W L"System.Runtime.InteropServices.PreserveSigAttribure"
+#define INTEROP_PRESERVESIG_TYPE "System.Runtime.InteropServices.PreserveSigAttribure"
+#define INTEROP_PRESERVESIG_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_BOOLEAN}
+
+#define INTEROP_IN_TYPE_W L"System.Runtime.InteropServices.InAttribute"
+#define INTEROP_IN_TYPE "System.Runtime.InteropServices.InAttribute"
+#define INTEROP_IN_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_OUT_TYPE_W L"System.Runtime.InteropServices.OutAttribute"
+#define INTEROP_OUT_TYPE "System.Runtime.InteropServices.OutAttribute"
+#define INTEROP_OUT_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_COMALIASNAME_TYPE_W L"System.Runtime.InteropServices.ComAliasNameAttribute"
+#define INTEROP_COMALIASNAME_TYPE "System.Runtime.InteropServices.ComAliasNameAttribute"
+#define INTEROP_COMALIASNAME_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define INTEROP_PARAMARRAY_TYPE_W L"System.ParamArrayAttribute"
+#define INTEROP_PARAMARRAY_TYPE "System.ParamArrayAttribute"
+#define INTEROP_PARAMARRAY_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_LCIDCONVERSION_TYPE_W L"System.Runtime.InteropServices.LCIDConversionAttribute"
+#define INTEROP_LCIDCONVERSION_TYPE "System.Runtime.InteropServices.LCIDConversionAttribute"
+#define INTEROP_LCIDCONVERSION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I4}
+
+#define INTEROP_COMSUBSTITUTABLEINTERFACE_TYPE_W L"System.Runtime.InteropServices.ComSubstitutableInterfaceAttribute"
+#define INTEROP_COMSUBSTITUTABLEINTERFACE_TYPE "System.Runtime.InteropServices.ComSubstitutableInterfaceAttribute"
+#define INTEROP_COMSUBSTITUTABLEINTERFACE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_DECIMALVALUE_TYPE_W L"System.Runtime.CompilerServices.DecimalConstantAttribute"
+#define INTEROP_DECIMALVALUE_TYPE "System.Runtime.CompilerServices.DecimalConstantAttribute"
+#define INTEROP_DECIMALVALUE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 5, ELEMENT_TYPE_VOID, ELEMENT_TYPE_U1, ELEMENT_TYPE_U1, ELEMENT_TYPE_U4, ELEMENT_TYPE_U4, ELEMENT_TYPE_U4}
+
+#define INTEROP_DATETIMEVALUE_TYPE_W L"System.Runtime.CompilerServices.DateTimeConstantAttribute"
+#define INTEROP_DATETIMEVALUE_TYPE "System.Runtime.CompilerServices.DateTimeConstantAttribute"
+#define INTEROP_DATETIMEVALUE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I8}
+
+#define INTEROP_IUNKNOWNVALUE_TYPE_W L"System.Runtime.CompilerServices.IUnknownConstantAttribute"
+#define INTEROP_IUNKNOWNVALUE_TYPE "System.Runtime.CompilerServices.IUnknownConstantAttribute"
+#define INTEROP_IUNKNOWNVALUE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_IDISPATCHVALUE_TYPE_W L"System.Runtime.CompilerServices.IDispatchConstantAttribute"
+#define INTEROP_IDISPATCHVALUE_TYPE "System.Runtime.CompilerServices.IDispatchConstantAttribute"
+#define INTEROP_IDISPATCHVALUE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_AUTOPROXY_TYPE_W L"System.Runtime.InteropServices.AutomationProxyAttribute"
+#define INTEROP_AUTOPROXY_TYPE "System.Runtime.InteropServices.AutomationProxyAttribute"
+#define INTEROP_AUTOPROXY_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_BOOLEAN}
+
+#define INTEROP_TYPELIBIMPORTCLASS_TYPE_W L"System.Runtime.InteropServices.TypeLibImportClassAttribute"
+#define INTEROP_TYPELIBIMPORTCLASS_TYPE "System.Runtime.InteropServices.TypeLibImportClassAttribute"
+
+
+#define INTEROP_TYPELIBVERSION_TYPE_W L"System.Runtime.InteropServices.TypeLibVersionAttribute"
+#define INTEROP_TYPELIBVERSION_TYPE "System.Runtime.InteropServices.TypeLibVersionAttribute"
+#define INTEROP_TYPELIBVERSION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 2, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2, ELEMENT_TYPE_I2}
+
+#define INTEROP_COMCOMPATIBLEVERSION_TYPE_W L"System.Runtime.InteropServices.ComCompatibleVersionAttribute"
+#define INTEROP_COMCOMPATIBLEVERSION_TYPE "System.Runtime.InteropServices.ComCompatibleVersionAttribute"
+#define INTEROP_COMCOMPATIBLEVERSION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 4, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I2, ELEMENT_TYPE_I2, ELEMENT_TYPE_I2, ELEMENT_TYPE_I2}
+
+#define INTEROP_COMEVENTINTERFACE_TYPE_W L"System.Runtime.InteropServices.ComEventInterfaceAttribute"
+#define INTEROP_COMEVENTINTERFACE_TYPE "System.Runtime.InteropServices.ComEventInterfaceAttribute"
+
+#define INTEROP_COCLASS_TYPE_W L"System.Runtime.InteropServices.CoClassAttribute"
+#define INTEROP_COCLASS_TYPE "System.Runtime.InteropServices.CoClassAttribute"
+
+#define INTEROP_SERIALIZABLE_TYPE_W L"System.SerializableAttribute"
+#define INTEROP_SERIALIZABLE_TYPE "System.SerializableAttribute"
+#define INTEROP_SERIALIZABLE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define INTEROP_SETWIN32CONTEXTINIDISPATCHATTRIBUTE_TYPE_W L"System.Runtime.InteropServices.SetWin32ContextInIDispatchAttribute"
+#define INTEROP_SETWIN32CONTEXTINIDISPATCHATTRIBUTE_TYPE "System.Runtime.InteropServices.SetWin32ContextInIDispatchAttribute"
+#define INTEROP_SETWIN32CONTEXTINIDISPATCHATTRIBUTE_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define FORWARD_INTEROP_STUB_METHOD_TYPE_W L"System.Runtime.InteropServices.ManagedToNativeComInteropStubAttribute"
+#define FORWARD_INTEROP_STUB_METHOD_TYPE "System.Runtime.InteropServices.ManagedToNativeComInteropStubAttribute"
+
+#define FRIEND_ASSEMBLY_TYPE_W L"System.Runtime.CompilerServices.InternalsVisibleToAttribute"
+#define FRIEND_ASSEMBLY_TYPE "System.Runtime.CompilerServices.InternalsVisibleToAttribute"
+#define FRIEND_ASSEMBLY_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 2, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING, ELEMENT_TYPE_BOOLEAN}
+
+#define FRIEND_ACCESS_ALLOWED_ATTRIBUTE_TYPE_W L"System.Runtime.CompilerServices.FriendAccessAllowedAttribute"
+#define FRIEND_ACCESS_ALLOWED_ATTRIBUTE_TYPE "System.Runtime.CompilerServices.FriendAccessAllowedAttribute"
+#define FRIEND_ACCESS_ALLOWED_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define SUBJECT_ASSEMBLY_TYPE_W L"System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute"
+#define SUBJECT_ASSEMBLY_TYPE "System.Runtime.CompilerServices.IgnoresAccessChecksToAttribute"
+#define SUBJECT_ASSEMBLY_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_STRING}
+
+#define DISABLED_PRIVATE_REFLECTION_TYPE_W L"System.Runtime.CompilerServices.DisablePrivateReflectionAttribute"
+#define DISABLED_PRIVATE_REFLECTION_TYPE "System.Runtime.CompilerServices.DisablePrivateReflectionAttribute"
+#define DISABLED_PRIVATE_REFLECTION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define DEFAULTDOMAIN_STA_TYPE_W L"System.STAThreadAttribute"
+#define DEFAULTDOMAIN_STA_TYPE "System.STAThreadAttribute"
+#define DEFAULTDOMAIN_STA_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define DEFAULTDOMAIN_MTA_TYPE_W L"System.MTAThreadAttribute"
+#define DEFAULTDOMAIN_MTA_TYPE "System.MTAThreadAttribute"
+#define DEFAULTDOMAIN_MTA_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 0, ELEMENT_TYPE_VOID}
+
+#define DEFAULTDOMAIN_LOADEROPTIMIZATION_TYPE_W L"System.LoaderOptimizationAttribute"
+#define DEFAULTDOMAIN_LOADEROPTIMIZATION_TYPE "System.LoaderOptimizationAttribute"
+#define DEFAULTDOMAIN_LOADEROPTIMIZATION_SIG {IMAGE_CEE_CS_CALLCONV_DEFAULT_HASTHIS, 1, ELEMENT_TYPE_VOID, ELEMENT_TYPE_I1}
+
+#define NONVERSIONABLE_TYPE_W L"System.Runtime.Versioning.NonVersionableAttribute"
+#define NONVERSIONABLE_TYPE "System.Runtime.Versioning.NonVersionableAttribute"
+
+// Keep in sync with CompilationRelaxations.cs
+typedef enum CompilationRelaxationsEnum
+{
+ CompilationRelaxations_NoStringInterning = 0x0008,
+
+} CompilationRelaxationEnum;
+
+#define COMPILATIONRELAXATIONS_TYPE_W L"System.Runtime.CompilerServices.CompilationRelaxationsAttribute"
+#define COMPILATIONRELAXATIONS_TYPE "System.Runtime.CompilerServices.CompilationRelaxationsAttribute"
+
+
+// Keep in sync with RuntimeCompatibilityAttribute.cs
+#define RUNTIMECOMPATIBILITY_TYPE_W L"System.Runtime.CompilerServices.RuntimeCompatibilityAttribute"
+#define RUNTIMECOMPATIBILITY_TYPE "System.Runtime.CompilerServices.RuntimeCompatibilityAttribute"
+
+
+// Keep in sync with AssemblySettingAttributes.cs
+
+typedef enum NGenHintEnum
+{
+ NGenDefault = 0x0000, // No preference specified
+
+ NGenEager = 0x0001, // NGen at install time
+ NGenLazy = 0x0002, // NGen after install time
+ NGenNever = 0x0003 // Assembly should not be ngened
+} NGenHintEnum;
+
+typedef enum LoadHintEnum
+{
+ LoadDefault = 0x0000, // No preference specified
+
+ LoadAlways = 0x0001, // Dependency is always loaded
+ LoadSometimes = 0x0002, // Dependency is sometimes loaded
+ LoadNever = 0x0003 // Dependency is never loaded
+} LoadHintEnum;
+
+#define DEFAULTDEPENDENCY_TYPE_W L"System.Runtime.CompilerServices.DefaultDependencyAttribute"
+#define DEFAULTDEPENDENCY_TYPE "System.Runtime.CompilerServices.DefaultDependencyAttribute"
+
+#define DEPENDENCY_TYPE_W L"System.Runtime.CompilerServices.DependencyAttribute"
+#define DEPENDENCY_TYPE "System.Runtime.CompilerServices.DependencyAttribute"
+
+#define TARGET_FRAMEWORK_TYPE_W L"System.Runtime.Versioning.TargetFrameworkAttribute"
+#define TARGET_FRAMEWORK_TYPE "System.Runtime.Versioning.TargetFrameworkAttribute"
+
+#define ASSEMBLY_METADATA_TYPE_W L"System.Reflection.AssemblyMetadataAttribute"
+#define ASSEMBLY_METADATA_TYPE "System.Reflection.AssemblyMetadataAttribute"
+
+
+#define CMOD_CALLCONV_NAMESPACE_OLD "System.Runtime.InteropServices"
+#define CMOD_CALLCONV_NAMESPACE "System.Runtime.CompilerServices"
+#define CMOD_CALLCONV_NAME_CDECL "CallConvCdecl"
+#define CMOD_CALLCONV_NAME_STDCALL "CallConvStdcall"
+#define CMOD_CALLCONV_NAME_THISCALL "CallConvThiscall"
+#define CMOD_CALLCONV_NAME_FASTCALL "CallConvFastcall"
+
+#endif // MACROS_NOT_SUPPORTED
+
+//
+// GetSaveSize accuracy
+//
+#ifndef _CORSAVESIZE_DEFINED_
+#define _CORSAVESIZE_DEFINED_
+typedef enum CorSaveSize
+{
+ cssAccurate = 0x0000, // Find exact save size, accurate but slower.
+ cssQuick = 0x0001, // Estimate save size, may pad estimate, but faster.
+ cssDiscardTransientCAs = 0x0002, // remove all of the CAs of discardable types
+} CorSaveSize;
+#endif
+
+#define COR_IS_METHOD_MANAGED_IL(flags) ((flags & 0xf) == (miIL | miManaged))
+#define COR_IS_METHOD_MANAGED_OPTIL(flags) ((flags & 0xf) == (miOPTIL | miManaged))
+#define COR_IS_METHOD_MANAGED_NATIVE(flags) ((flags & 0xf) == (miNative | miManaged))
+#define COR_IS_METHOD_UNMANAGED_NATIVE(flags) ((flags & 0xf) == (miNative | miUnmanaged))
+
+//
+// Enum used with NATIVE_TYPE_ARRAY.
+//
+typedef enum NativeTypeArrayFlags
+{
+ ntaSizeParamIndexSpecified = 0x0001,
+ ntaReserved = 0xfffe // All the reserved bits.
+} NativeTypeArrayFlags;
+
+//
+// Opaque types for security properties and values.
+//
+typedef void * PSECURITY_PROPS ;
+typedef void * PSECURITY_VALUE ;
+typedef void ** PPSECURITY_PROPS ;
+typedef void ** PPSECURITY_VALUE ;
+
+//-------------------------------------
+//--- Security data structures
+//-------------------------------------
+
+// Descriptor for a single security custom attribute.
+typedef struct COR_SECATTR {
+ mdMemberRef tkCtor; // Ref to constructor of security attribute.
+ const void *pCustomAttribute; // Blob describing ctor args and field/property values.
+ ULONG cbCustomAttribute; // Length of the above blob.
+} COR_SECATTR;
+
+#endif // __CORHDR_H__
+