JetBrains.Platform.Metadata

Indicates that the file is not a resource file

Indicates that the file, possibly a resource file, does not contain metadata

Contains number of bits to represent coded token. Indexed by number of possible values in given coded token type

Number of bits in coded token tag for a coded token that refers to n tables

Type of the encoded token in the CIL tables

Bits for heap offset/index sizes

If flag is set, #Strings heap offsets are stored as 4 bytes; 2 otherwise

If flag is set, #GUID heap indices are stored as 4 bytes; 2 otherwise

If flag is set, #Blob heap offsets are stored as 4 bytes; 2 otherwise

Tables can be created with an extra bit in columns, for growth

If set, only deltas were persisted

If set, schema persists an extra 4 bytes of data

If set, this metadata can contain _Delete tokens

PE file metadata reader

Has faster implementation of some methods

The image, in a pinnable blob (for binary search in metadata tables): either an , or any other implementation on which succeeds (see ).

Opens metadata access on a blob reader which is either pure metadata (WinMD, extracted, etc) or a PE file with metadata. If the reader can make a blob which supports , operates on it directly. Otherwise copies to native memory.

Opens metadata access directly on a BLOB which is either pure metadata (WinMD, extracted, etc) or a PE file with metadata.

Scans the stream for the PE structure (reads all headers, incl metadata stream headers). If metadata is detected, copies the metadata part of the file to native memory and opens metadata access on it. If you already have this content in memory, consider opening .

Returns null for metadata only stream

Provides metadata interface for various sources (ILReader version, only managed code)

Metadata tables reader

Read offset to the #Strings heap

Read index to the #GUID heap

Read offset to the #Blob heap

Rows in metadata delta TypeDef, MethodDef, etc. tables have 0 (null) values for MethodList, FieldList, ParamList and other *List => need to use the corresponding values from the original (initial) table => use GetInitialEntityValue instead of GetEntityValue for *List columns

ECMA-335 p.22

Portable PDB Signature should match ((DebugInfo7)DebugDirectory.Entry.GetEntry()).Signature in PE file (Version (DebugDirectory.Entry) Major=any, Minor=0x504d. The Age shall be 1.)

Portable PDB TimeDateStamp should match DebugDirectory.Entry.DateTimeStamp in PE file

True if the metadata stream has minimal delta format. Used for EnC.

The metadata stream has minimal delta format if "#JTD" stream is present. Minimal delta format uses large size (4B) when encoding table/heap references. The heaps in minimal delta only contain data of the delta, there is no padding at the beginning of the heaps that would align them with the original full metadata heaps. (#GUID heap accumulates - previous heap is copied to the next generation ???)

Optional. When you create this from a PE file, then the PE reader already has the metadata header loaded and parsed. Avoid doing this twice by passing the existing instance. Will read locally when NULL.

Read coded (multi targeting) token

Set of the token targets

Structure for storing typedef properties

Gets fully qualified type name

Gets base token

Gets typedef flags

Structure for storing typeref properties

Gets type reference resolution scope

Gets references type namespace name

Gets references type name (without namespace)

Gets references type name (namespace_name.type_name)

Gets name of generic parameter

Gets generic parameter index

Gets owner token

Gets generic param attributes

Gets generic parameter constraints

.ctor method token (the owner of that constructor method is the type of the custom attribute)

Stores properties of a member reference

Stores properties of an assembly reference

Interface for accessing metadata in an abstract way

Metadata provider used to create metadata access

Gets assembly info interface if available

Gets unique MVID and size

Gets ModuleName

Gets target platform

Gets array of all available module references

Gets array of all available typedef tokens

Gets properties of a typedef

Gets properties of a typeref

Gets blob for typeSpec

Gets blob for StandAloneSig

Gets blob for typeSpec

Find all MethodSpec records for concrete method def or ref

MethodDefOrRef token Array of corresponding MethodSpec tokens

Gets array of generic type parameters for the specified owner

Gets properties of a generic type parameter

Gets properties of a generic parameter constraint

Gets InterfaceImpl tokens for specified type

Gets MethodImpl tokens for specified type

Gets properties of an interface implementation

Gets member (field, method, event or property) name

Gets array of type fields

Gets field properties

Gets array of type methods

Gets method properties

Gets method parameters

Gets parameter by its index in method signature

Gets parameter properties

Gets array of type properties

Gets property properties

Gets array of type events

Gets event properties

Gets enclosing type

Gets array of custom attributes attached to the specified entity

Gets custom attribute properties

Gets custom attribute type fully qualified name

Gets properties of a module reference

Gets properties of a member reference

Gets properties of an assembly reference

Gets properties of a file

Gets properties of a manifest resource

Gets method implementation map (method body -> method declarations array; from MethodImpl table) for a type

Gets tokens of declarations of [explicitly] implemented methods

GetMethods(typeToken).Contains(methodBodyToken)

Gets PInvoke dispatch information for method

Gets ImplMap information

Gets Edit and Continue Log information

Gets Edit and Continue Map information

Gets marshalling specification for field or parameter if available, null if not

Gets array of type references from the assembly

Gets class layout if specified, null if not

Get DeclSecurity rows

Get DeclSecurity properties

Get DeclSecurity attribute types names (extracted from blob)

Finds a record in TypeRef table

Enumerates all TypeSpec records

Enumerates all MethodSpec records

Enumerates all StandAloneSig records

Enumerates all MethodDef records

Enumerates all File records

Enumerates all ExportedType records

Enumerates all ManifestResource records

Enumerates all MemberRef records

Finds all MemberRefs owned by type

Nested-relation between types

Mapping between qualified type names and their typedef tokens

Returns code RVA for every method in assembly. Offset in array corresponds to method RID (at zero position - RID 1)

Returns embedded resource offset (in PE file) by resource offset from metadata table or -1 if not available

Enumerates all Field records

Enumerates all Property records

Enumerates all Event records

Enumerates all ImplMap records

Enumerates all Edit and Continue Log records

Enumerates all Edit and Continue Map records

Enumerates all Document records

Enumerates all MethodDebugInformation records

Enumerates all LocalScope records

Gets array of scope local variables

Gets array of scope local constants

Enumerates all ImportScope records

Enumerates all CustomDebugInformation records

Exported type token

The name of the exported type

The namespace of the exported type

An mdFile, mdAssemblyRef, or mdExportedType metadata token that contains or allows access to the properties of the exported type

mdTypeDef token that represents a type in the file

flags that describe the metadata applied to the exported type

The simple name of the file

Token of file reference

flags that describe the metadata applied to a file

Provides access to assembly metadata info

Gets full assembly name

Gets names of referenced assemblies (from AssemblyRef table)

Gets names of referenced modules (from ModuleRef table)

Get ExportedType table (types, defined within OTHER modules of THIS assembly) ExportedType table stores TypeDef row numbers of all types that are marked public in other modules that this Assembly comprises

Do not confuse this method with System.Reflection.Assembly.GetExportedTypes() method (which returns public types defined in this assembly that are visible outside the assembly)

files referenced in the current assembly manifest

Gets assembly token

You must call DisposeMetadataAccess after every GetFrom* method, but if you're loading assemblies via MetadataLoader that will be done for you automatically on loader dispose

Gets the string from userstring (#US) heap

use 1-based indices The physical heap can contain garbage, that is, it can contain parts that are unreachable from any of the tables. For heap \0ABCDEF\0 this method returns {{0,""}, {1, "ABCDEF"}}, however, string "CDEF" can be reached from another table by offset 3, while string "ABCDEF" can be unreachable at the same time (there is no table which contains string offset 1). We do not skip garbage for performance reason (to do this we need to read all string offset usages from all tables). Can contain garbage (see )

Provides direct access to blob heap, do not use it except for optimization

Row count for metadata table

Size without 4b aligning zeros (only one terminating zero at the end)

Provides metadata interface for various sources

Metadata tables

Partition II: Metadata Definition and Semantics. 22 Metadata logical format: tables. bh - Blob heap, sh - String heap, gh - GUID heap null - for reserved values, column can be skipped in table presentation

MetadataTokenType valuesfor corresponding tokens (RID for table tokens) ColumnDataType.StringHeapfor offset in #Strings ColumnDataType.BlobHeapfor offset in #Blob ColumnDataType.GuidHeapfor index in #GUID Negative values (ColumnDataType.OneByte, ColumnDataType.TwoBytes, ColumnDataType.FourBytes)for -number of bytes

If true then DataType has MetadataTokenType value (less than or equal to MaxTableTokenType). Token (RID of token) in this column marks the first of a contiguous run of tokens in corresponding table (with id (MetadataTableId)DataType). null only if !IsFlags

Represents metadata token

Enumerates prologs for different signatures

PE / 32BITREQ / 32BITPREF PE32 / 0 / 0 PE32 / 1 / 0 PE32 / 0 / 1 PE32+ / 0 / 0

32BITREQ - cliFlags contains and does not contain ; 32BITPREF - cliFlags contains and

Detects target platform of a PE file

path to file if set to true the method will detect platform for native PEs (instead of returning Unknown). If false the method returns Unknown for any non-CLI file

Detects target platform of a PE file

path to file if set to true the method will detect platform for native PEs (instead of returning Unknown). If false the method returns Unknown for any non-CLI file

Сan be used to display verification errors and make a decision to continue verification.

Method called when an error occurs during the verification process.

true to continue the verification process otherwise false

Type / type member token

Method which contains original and sequence point instructions

Original instruction

Sequence point instruction associated with original instruction (with IL offset less or equal to original instruction IL offset)

If both sequence point instructions from one method then chooses first of them, otherwise returns ir1 (If one of the instructions is null then choose another)

Gets instruction ir.Instruction index in ir.MethodBody.Instructions array (returns -1 in case of error)

IL instruction (with corresponding method) of sequence point

OwnNamespace is used to determine import scopes tree structure

Collection of sequence points for one source file.

Gets metadata tokens of methods containing sequence points from this collection

Token of the entry point method (null for dll)

Source files

Path to pdb file from which the data was obtained

Should be null for decompiler-generated DebugData

Ranges of types / methods / etc for source file with given index

Creates document with given url and adds it to content

Creates document with given parameters and adds it to content

Gets (or creates and adds to content, if missing) document for the url

Gets existing source with baseDocument.URL name or creates new

baseDocument.Index is ignored, so input and output documents may have different indices

Document with the same name and the longest common suffix with the given path

Creates and adds to content method with token methodToken and [0, codeLength] IL range

Method IL code length in bytes

Gets method for the token (fails if such method is missing)

Generates next index (starting from 1)

1-based index of source file, if it is only one in debugData, DebugDocument.NullDocumentIndex otherwise DocumentIndex that all sequence points have, DebugDocument.InvalidDocumentIndex otherwise Sequence points can have DebugDocument.NullDocumentIndex DocumentIndex, it means that containing DebugData does not have any documents

Adds local variable to scope that encloses the entire method (RootScope)

Adds local variable to scopes covering [scopeStartOffest, scopeEndOffset]

Create DebugData from data related to document with documentIndex

Create DebugData from data related to documents with documentIndices

Partial implementation of System.Diagnostics.SymbolStore.ISymbolDocument

1 based

The URL (file name) of the current document

Gets the type of the current document

Gets the language of the current document

Gets the language vendor of the current document

Gets the checksum algorithm id of the current document

Gets the checksum of the current document

Updates all data except Index

For combine infos from WindowsPdbFile.ReadStreamNames (only lowercase URL and index) and DocumentInfoVisitor.Visit_FILECHKSMS (all document info except index)

System.Diagnostics.SymbolStore.ISymbolVariable

The name of the variable

The metadata token of the local variables signature for method

The local variable attributes

see SymAddressKind.ILOffset

Partial implementation of System.Diagnostics.SymbolStore.ISymbolMethod

The metadata token for the current method

The metadata token of the local variables signature for this method

The root lexical scope that encloses the entire method.

Set importScope to all nodes of method's LocalScope tree

Gets if there're no sequence points in the method

Sequence points for the current method (sorted in the increasing order of IL offsets)

Sequence points for the current method in specified source file (sorted in the increasing order of IL offsets)

Indices of source files in which current method is defined

Slow!!!

Source of local variable names (pdb path, decompiler, etc.)

AssemblyRef token or MetadataToken.Nil if not set TypeDef, TypeRef or TypeSpec token or MetadataToken.Nil if not set

Represents a lexical scope within DebugMethod, providing access to the start and end offsets of the scope, as well as its child and parent scopes. (see System.Diagnostics.SymbolStore.ISymbolScope)

The method that contains the current lexical scope

The parent lexical scope of the current scope (null for root scope of the DebugMethod)

The start offset of the current lexical scope

The end offset of the current lexical scope

The child lexical scopes of the current lexical scope

The local variables within the current lexical scope

Returns local variable with specified index if this variable is presented within the current lexical scope, null otherwise

Returns local variable with specified index if this variable is presented within parent scopes of current lexical scope, null otherwise

Adds local variable and returns true if local variable with index localVariable.IlIndex is not contained in this, child or parent scopes, otherwise returns false

Adds obtained inner scopes (existed or created) covering [startOffest, endOffset] to scopes collection

For Windows Pdb only

The method that initializes and starts the state machine (for MoveNext method that implements the state transition)

Creates bit set where IsSet(index) when index less than num

Creates bit set where IsSet(index) when index in indices

maximum value of index in indices

Creates bit set where IsSet(index) when index in sortedIndices (sortedIndices[i] not greater than sortedIndex[i + 1])

PDB stream descriptor

ctor

Stream size

Stream blocks

PDB (v 2.0) stream information stored in the Table of the Contents

ctor

Stream size

Stream for reading sub range of the underlayed stream

C# only. Encodes the sizes of using groups that are applicable to the method. The actual import strings are stored separately through ISymUnmanagedWriter.UsingNamespace.

C# only. Indicates that per-method debug information (import strings) is stored on another method, whose token is specified.

C# only. Indicates that per-module debug information (assembly reference aliases) is stored on another method, whose token is specified.

C# only. Specifies local scopes for state machine hoisted local variables.

C# and VB. The name of the state machine type. Emitted for async and iterator kick-off methods.

C# only. Dynamic flags for local variables and constants.

C# and VB. Encodes EnC local variable slot map.

C# and VB. Encodes EnC lambda map.

C# and VB. Tuple element names for local variables and constants.

C# and VB. Syntax offsets of nodes associated with state machine states in an async/iterator method and their corresponding state numbers.

Dbg header size in bytes

Size in bytes of file info section of DBI stream

DBI header size in bytes

Pdb file age (ever-incrementing value, which is initially set to 1 and incremented every time when a part of the PDB file is updated without rewriting the whole file) (assembly should have the same age and guid signature as pdb)

Size in bytes of module info without align (but with strings)

Module info size in bytes (4 bytes align is taken into account)

DBI section contribution size in bytes

After call this method adding streams is not allowed

Calculates size of string s in bytes for UTF8 encoding

Null if we cannot extract signature, for example an assembly file is not found

Function code length in bytes

Preprocessor directives defined in Portable pdb (CustomDebugInformation table, row with CompilationOptions kind, part of Value blob with 'define' name)

1 based; DebugDocument.NullDocumentIndex if index can't be determined

Function IL code length in bytes

PDB 7.0 file header info

Pdb header size in bytes

Signature

Size of the file blocks

Count of debug info pages

Size of the Table of Contents

Index of the TOC Pointers Page

First page in PDB

Pdb file name without .pdb extension

<guid><age> or <guid>FFFFFFFF

Extracts embedded portable Pdb to temp file

lifetime of temporary file temporary file path

Root record of the PDB info

Ctor

Symbolic info version

TimeStamp

Symbolic info ID (SymId) (a unique identifier, which changes with every rebuild of the executable and PDB file) (assembly should have the same signature as pdb)

PDB File table of the contents

Streams existed in the PDB File

Return checksum from PE file / WebCIL WebAssembly with preferable algorithm.

string in format [ALGO]:[HEXSUM] SHA256:B6BD70C213FD15DB859068A5DB485BE5FB82FB05EE77D22B8E7D852BD8FB6BC8

Return checksum from PE fie with preferable algorithm.

string in format [ALGO]:[HEXSUM] SHA256:B6BD70C213FD15DB859068A5DB485BE5FB82FB05EE77D22B8E7D852BD8FB6BC8 Only Standalone and StandalonePortable types

Signature and Age of Windows PDB

Signature and TimeDateStamp of standalone Portable PDB

Infer sources names for types without mapping and add this new mappings to typeToFiles

initially contains only existing mappings (obtained from sequence points) FQNs from TypeDef metadata table sources names from pdb FQNs for types with inferred sources names

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxFFFFFFFF

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1

<guid>FFFFFFFF -> <guid>1

<guid>1 -> <guid>FFFFFFFF

If returned value is not null, it has type If returned value is not null, it has type If returned value is not null, it has type or If returned value is not null, it has type or If returned value is not null, it has type or If returned value is not null, it has type or or Type to files mapping can be retrieved only when we have information about types (i.e. we have assembly metadata) null if assembly passed to ctor is null

Calculate myTypeToFiles and myTypesWithInferredMapping

Index of Document table row with Name == documentName (ignore case) or DebugDocument.NullDocumentIndex if such row is absent

Content of CustomDebugInformation Value blob for row: Kind - Embedded Source, Parent - Document with index documentIndex or null if such row is absent

reverse to Call on the main thread

Replaces signature and age info in PDB header

For each namespace declaration enclosing a method (innermost-to-outermost), there is a count of the number of imports in that declaration.

There's always at least one entry (for the global namespace).

This indicates that further information can be obtained by looking at the custom debug info of another method (specified by token).

Appears when multiple method would otherwise have identical using records (see ).

Tuple element names for locals.

GetDebugData(...).TryGetDocument(documentName).(Index, Checksum) equals to GetDocumentNameToInfoDictionary()[documentName]

Sequence point within the current method. StartLine and StartColumn define the start of a statement within a method in source file with index DocumentIndex. EndLine and EndColumn define the end of a statement within a method.

The IL offset of the sequence point measured from the beginning of the method (in bytes)

The starting line number of the sequence point

The starting column number of the sequence point

The ending line number of the sequence point

The ending column number of the sequence point

if sequence point is hidden then the debugger will skip over it

Index of source file where statement is located (DebugDocument.Index)

Redirects instructionIndex to associated sequence point instruction index (returns -1 in case of error)

Branch instruction can be associated with hidden SP if branch target instruction is after this instruction and there are regular SP between this instruction and branch target instruction

Returns offsets of all hidden sequence points

Optional program database (PDB) file for this DLL.

Optional XmlDoc file for this DLL.

Checks for the existing files and chooses the assembly extension from the list, eg “exe” or “dll”. Throws if not found.

Assembly name reader in managed code. No .NET framework or Fusion API used. Opens files in non-blocking mode.

Info from ModuleRef (0x1A) table

Info from AssemblyRef (0x23) table

Assembly name reader in managed code. By default, uses our metadata reader, opens files in non-blocking mode. See reader choice for other options. No .NET framework or Fusion API used. DOES NOT CHECK FOR THE FILE EXISTENCE!

Gets whether this metadata reader has valid tables from which we read assembly name and MVID. A PPDB file would be a valid metadata file, but would not have a Module table, for example.

Classic. Wraps the given stream with a binary reader, then uses our PE Reader + Metadata Reader for parsing.

Optimized for file access. If the stream is from a disk file, maps the file into memory and uses a BLOB on that native memory. Uses our PE Reader + Metadata Reader for parsing. For disk files which are OK to be locked for MMFing, this is faster.

Roslyn implementation, for reference and perf comparison mainly. Approximately as fast as our MMF, when on a disk file, otherwise slower. Roslyn first reads the PE headers from the stream and then opens an MMF, if possible, for metadata tables access. Thus it is much faster to open the MMF from start.

Helps with looking up the referenced assemblies.

The list of base directories to be probed for the assembly being resolved.

The list of appdomains we've been installed onto.

Creates the instance. Call to attach, don't forget to call or to detach on shutdown.

The list of base directories to be probed for the assembly being resolved.

Creates a resolver over the single probing directory that is the home directory of the .

Creates a resolver over the single probing directory .

Starts listening for failed assembly loads on the given appdomain.

Stops listening for failed assembly loads on the given appdomain. It is not an error to uninstall from a non-installed appdomain.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Takes a set of assemblies (as file paths). Reads their references (with metadata reader, not runtime) and tries to look up in the same folders as the set of assemblies. Adds only those found, transitively. Returns paths with actual names on disk (not as written in references, but as found in files, no runtime correction).

Trim "Attribute" suffix if it exists

Attribute type name length (without "Attribute" suffix)

Ensures the resulting blob can serve (that you can pin its memory for random access without any overhead).

Access the memory under the binary reader as a BLOB. Unwraps the memory under the binary reader to directly read it as a BLOB, as much as possible. Otherwise, it's a BLOB API adapter over a reader. This DOES NOT take into account the current position in the reader. Its whole range of bytes is represented as a BLOB. Thread safety: UNSAFE. If the reader were not on memory but, say, on a stream, then BLOB API would be a wrapper over the stream. Even though shared use of the stream thru multiple readers/blobs is still valid (they will ensure correct position before reading), it MUST NOT happen simultaneously from different threads.

Creates accessor to BLOB memory.

Creates accessor to random-access memory.

Creates accessor to a sequential stream. Attempts to unwrap streams over random-access memory and return such a binary reader which would then serve pinnable BLOBs for metadata access. If the stream is genuinely sequential, makes a wrapper; metadata access would copy this memory if created over it.

File is not app host

App host is single-file bundle

Location of file entry inside single file bundle (location of bundle file + pointer to file entry inside bundle)

0 indicates No Compression For use as key in dictionary (or for comparison) only some methods or properties may throw exceptions (OpenForReading, FileEntryRelativePath, etc.)

BundleManifest is a description of the contents of a bundle file. This class handles creation and consumption of bundle-manifests. Here is the description of the Bundle Layout: _______________________________________________ AppHost ------------Embedded Files --------------------- The embedded files including the app, its configuration files, dependencies, and possibly the runtime. ------------ Bundle Header ------------- MajorVersion MinorVersion NumEmbeddedFiles ExtractionID DepsJson Location [Version 2+] Offset Size RuntimeConfigJson Location [Version 2+] Offset Size Flags [Version 2+] - - - - - - Manifest Entries - - - - - - - - - - - Series of FileEntries (for each embedded file) [File Type, Name, Offset, Size information] _________________________________________________

Bundle ID is a string that is used to uniquely identify this bundle. It is chosen to be compatible with path-names so that the AppHost can use it in extraction path.

Length in bytes (including length prefix)

The Minor version is currently unused, and is always zero

Check if the an AppHost is a single-file bundle or native exe with corresponding managed dll

The path of Apphost to check An out parameter containing the offset of the bundle header (if any) bundleHeader is not null for AppHostType.SingleFileBundle

FileEntry: Records information about embedded files. The bundle manifest records the following meta-data for each file embedded in the bundle: * Type (1 byte) * NameLength (7-bit extension encoding, typically 1 byte) * Name ("NameLength" Bytes) * Offset (Int64) * Size (Int64) === present only in bundle version 3+ (or 6+???) * CompressedSize (Int64) 0 indicates No Compression

Path of an embedded file, relative to the Bundle source-directory.

Length in bytes (including length prefix)

FileType: Identifies the type of file embedded into the bundle. The bundler differentiates a few kinds of files via the manifest, with respect to the way in which they'll be used by the runtime.

NetcoreApp3CompatMode flag is set on a .net5 app, which chooses to build single-file apps in .netcore3.x compat mode, by constructing the bundler with BundleAllContent option. This mode is expected to be deprecated in future versions of .NET.

Short names of properties, fields, events, nested types of typeElement (and its base type) which may conflict with names of used types

Count of lines at document start (before code lines). All positions should be shifted after appending lines at document start (e.g. comments in header)

All namespaces with definition of type with short name and parameters count

All namespaces with definition of attribute with short name and parameters count (short name without attribute suffix trimming)

short names of properties, fields, events, nested types (which may conflict with names of used types) The set of types being referenced The set of attributes being referenced

Parent namespaces of given namespace including namespace itself

Used mainly for debugging purpose.

A type to format. Format types with or without namespace A string representing the type.

Renders a method name for Smart Step Into, respecting the local function naming.

Method to render. Method or local function name. currentLineEstimatedLength is not taken into account when estimating length, but may affect the multiline calculation (see AstRenderer.TryRenderSingleLine, AstRenderer.CanBeRenderedInSingleLine; e.g. CanBeRenderedInSingleLine(RenderAsExpressionBodied) + TryRenderSingleLine(RenderArrayCreation)) If is true, then annotation for type (only, not for its generic arguments) is not rendered and nullable context is not switched true: do not use type aliases, spaces and nullable annotations

true - (Type1, ..., TypeN); false - ValueTuple<Type1, ..., TypeN>

Provides information about the type of code contained in an assembly.

Compares assembly identities. Derived types may implement platform specific unification and portability policies.

A set of possible outcomes of comparison.

Reference doesn't match definition.

Strongly named reference matches strongly named definition (strong identity is identity with public key or token), Or weak reference matches weak definition.

Reference matches definition except for version (reference version is lower or higher than definition version).

Compares assembly reference name (possibly partial) with definition identity.

Partial or full assembly display name. Full assembly display name. True if the reference name matches the definition identity.

Compares assembly reference identity with definition identity.

Reference assembly identity. Full assembly display name. True if the reference identity matches the definition identity.

Compares reference assembly identity with definition identity and returns their relationship.

Reference identity. Definition identity.

Converts to .

Major, minor, build or revision number are less than 0 or greater than 0xFFFF.

Returns true if the identity is a Framework 4.5 or lower assembly.

An assembly item, which can tell the name of the assembly and its bytes content.

Full name of this assembly.

The byte content of the assembly, as well as its original file name.

Optional properties for an assembly item.

Optional program database (PDB) file for this DLL.

Optional XmlDoc file for this DLL.

Reads the assembly MVID from the stream.

Gets an independent reader at the current position. The two readers are not thread-safe.

Gets an independent reader for the given sub-range of the current one, positioned at the beginning of the range, and reporting Position=0 at that point.

Range start. New reader will have Position=0 there. Will be initially positioned there. Range length. New reader will have such length and stop reading at range end.

Read zero-terminated UTF-8 string (C string)

Read length-prefixed UTF-8 string (compressed int is used for size)

Read zero-terminated UTF-8 string (C string)

Read length-prefixed UTF-8 string (compressed int is used for size)

Optionally supported by blobs if they're contiguous in memory. Gets direct safe access to blob memory. The blob instance SHOULD be consistent in whether it returns True or False from this. Especially it MUST NOT refuse giving a span after it successfully served it once.

Span, if returned True. Whether this instance supports spans. Optimized for one value per key not null tuple component type, if valueTupleType.IsGenericValueTuple and 0 <= componentIndex < valueTupleType.GetTupleComponentsCount(); null otherwise Index starting from 1; 0 in case of invalid item field name Consider using 'new StringDotConcat(ns, name).EqualTo(fqn)' instead of 'MakeTypeFqn(ns, name) == fqn' Zero-based index position of the first occurrence of comma (outside of angle brackets) if it is found, or -1 if it is not. Assumption: input string has regular bracket sequence

COFF file characteristics

Relocation info stripped from file.

File is executable (i.e. file is neither object file nor library file, so there are no unresolved external references).

Line numbers stripped from file.

Local symbols stripped from file.

Aggressively trim working set

Application can handle >2gb addresses

Use of this flag is reserved for future use

Bytes of machine word are reversed.

32 bit word machine.

Debugging info stripped from file in .DBG file

If Image is on removable media, copy and run from the swap file.

If Image is on Net, copy and run from the swap file.

This flag is used to indicate that the file is a system file, such as device driver.

This flag indicates that the file is a dynamic library (DLL).

File should only be run on a uniprocessor (UP) machine.

Bytes of machine word are reversed.

and flags interact as a pair (retaining backwards compatibility with pre-4.5 runtimes/OSs, which don't know about ): / 0 / 0 no special meaning, and flag determine image requirements 0 / 1 illegal 1 / 0 image is x86-specific 1 / 1 image is platform neutral and prefers to be loaded 32-bit when possible

CLI (Cor20) header

ctor

CLI Header + CLI Data (metadata, IL method bodies)

PE File CLI data header

Image offset within a file

CLI Metadata Header

PE file sections dictionary

Translate Relative Virtual Address (RVA) to the actual Virtual Address (VA)

RVA to translate

Read directory from PE File

Create PE directory according its Index

Directory index Size of directory Created object or null if: Directory type not implemented yet Passed Size of the directory less than required Unknown directory index passed

COFF header

A 4-byte signature identifying the file as a PE image. The bytes are "PE\0\0"

The architecture type of the computer. An image file can only be run on the specified computer or a system that emulates the specified computer.

The number of sections. This indicates the size of the section table, which immediately follows the headers. Note that the Windows loader limits the number of sections to 96.

The low 32 bits of the time stamp of the image. This represents the date and time the image was created by the linker. The value is represented in the number of seconds elapsed since midnight (00:00:00), January 1, 1970, Universal Coordinated Time, according to the system clock.

The offset of the symbol table, in bytes, or zero if no COFF symbol table exists.

The number of symbols in the symbol table

The size of the optional header, in bytes. This value should be 0 for object files.

The characteristics of the image

PE section information record

Data RVA

Data size

Base information about debug entry

Ever-incrementing value, which is initially set to 1 and incremented every time when a part of the PDB file is updated without rewriting the whole file

Name of the PDB file. It can also contain full or partial path to the file

PDB 2.0 debugging info

The time when debug information was created

PDB 7.0 Debugging info

A unique identifier, which changes with every rebuild of the executable and PDB file

Debug information headers in PE FILE.

Debug info entries located in directory

Read directory

reader Size of directory

Separate method to read DebugDirectory entries without the PEFile. Used in dotTrace

Debug Directory entry

ctor

Binary reader

Entry params

Seconds from 1970

Major version

Minor version

Debug info type

Data size

Address in PE file

Pointer to the data in PE File

Returns actual info stored in the referenced PE block

Read DebugInfo7 or DebugInfo2 structure from stream Caller must be sure that current stream position points to the begining of DebugInfo record Returns null if there is no proper signature in stream (neither CodeViewSignaturePdb7 nor CodeViewSignaturePdb2)

Signature of PDB for and , Guid.Empty for other types

Age of PDB for , TimeDateStamp of PDB for , 0 for other types

Name of the PDB file for and (it can also contain full or partial path to the file), null for other types

Type 2 (CodeView), data format version Major=0, Minor=0: standalone Windows (native) PDB Path, Signature and Age can be used to find the corresponding PDB file

Type 2 (CodeView), data format version Major=any, Minor=0x504d: standalone portable PDB Together 16 bytes of the Signature concatenated with 4 bytes of the TimeDateStamp form a PDB ID that should be used to match the PE/COFF image with the associated PDB (instead of Signature and Age; the Age shall be 1) Matching PDB ID is stored in the #Pdb stream of the .pdb file

Type 17, data format version Major=any, Minor=0x0100: embedded portable PDB

Type 16, other fields shall be zero Presence of this entry indicates that the containing PE/COFF file is deterministic If the containing PE/COFF file is deterministic the Signature and TimeDateStamp of the directory entry are calculated deterministically based solely on the content of the associated .pdb file. Otherwise the value of Signature is random and the value of TimeDateStamp indicates the time and date that the debug data was created.

Summary description for DebugType.

Export headers in PE FILE.

Read directory

reader Size of directory

Export Directory Name with info

https://docs.microsoft.com/en-us/previous-versions/windows/embedded/ms912047(v=winembedded.10)

Base class for PE directory

Read directory

reader Size of directory

(Data RVA) Address of a unit of resource data in the Resource Data area

Size, in bytes, of the resource data pointed to by the OffsetToData (Data RVA) field

Code page used to decode code point values within the resource data. Typically, the code page would be the Unicode code page.

Reserved (must be set to 0)

https://docs.microsoft.com/en-us/windows/desktop/menurc/resource-types

Optional NT header DllCharacteristics entry meanings

ASLR with 64 bit address space

DLL can be relocated at load time

Code integrity checks are enforced

Image is NX compatible

Isolation aware, but do not isolate the image

Does not use structured exception handling (SEH). No SEH handler may be called in this image

Do not bind the image

Image should execute in an AppContainer

A WDM driver

Image supports Control Flow Guard

Terminal Server aware

Image signatures

"MZ"

"NE"

"LE"

"PE", the complete signature is "PE\0\0"

second part of the PE FULL sig

Netadata header signature

Major version

Minor version

Reserved

CLR version

The length of the ASCII version string. The length has to be rounded up to a multiple of 4

Metadata flags

Metadata streams information

Exceptions raised during module IL reading

Ctor

Exception reason

Ctor

Exception reason Inner exception

Special ctor for deserialization

Standard HT optional header sizes

NT header

A pointer to the beginning of the data section, relative to the image base

The preferred address of the first byte of the image when it is loaded in memory. This value is a multiple of 64K bytes. The default value for DLLs is 0x10000000. The default value for applications is 0x00400000, except on Windows CE where it is 0x00010000

The number of bytes to reserve for the stack. Only the memory specified by the SizeOfStackCommit member is committed at load time; the rest is made available one page at a time until this reserve size is reached.

The number of bytes to commit for the stack

The number of bytes to reserve for the local heap. Only the memory specified by the SizeOfHeapCommit member is committed at load time; the rest is made available one page at a time until this reserve size is reached.

The number of bytes to commit for the local heap

NT header

The number of bytes to commit for the stack

The number of bytes to commit for the local heap

The alignment of sections loaded in memory, in bytes. This value must be greater than or equal to the FileAlignment member. The default value is the page size for the system.

The alignment of the raw data of sections in the image file, in bytes. The value should be a power of 2 between 512 and 64K (inclusive). The default is 512. If the SectionAlignment member is less than the system page size, this member must be the same as SectionAlignment.

The major version number of the required operating system

The minor version number of the required operating system

The major version number of the image

The minor version number of the image

The major version number of the subsystem

The minor version number of the subsystem

This member is reserved and must be 0

The size of the image, in bytes, including all headers. Must be a multiple of SectionAlignment

The combined size of the following items, rounded to a multiple of the value specified in the FileAlignment member: - e_lfanew member of DOS header, - 4 byte signature, - size of optional header, - size of all section headers.

The image file checksum. The following files are validated at load time: all drivers, any DLL loaded at boot time, and any DLL loaded into a critical system process.

The subsystem required to run this image

The DLL characteristics of the image

This member is obsolete

The number of directory entries in the remainder of the optional header. Each entry describes a location and size

PE File directory entry

Portable Executable file

ctor

PE file native image reader

PE File DOS stub header

PE File COFF header

PE File PE header

PE File Optional NT header

PE File directory infos

R2R header

Returns False if the DOS header was not detected.

PEFile (not CliImage, because WebCilPayload cannot contain Win32 resources) MetadataToken.Nil if entry point is absent

PE file section header

The state of the image file

The major version number of the linker

The minor version number of the linker

The size of the code section, in bytes, or the sum of all such sections if there are multiple code sections

The size of the initialized data section, in bytes, or the sum of all such sections if there are multiple initialized data sections

he size of the uninitialized data section, in bytes, or the sum of all such sections if there are multiple uninitialized data sections

A pointer to the entry point function, relative to the image base address. For executable files, this is the starting address. For device drivers, this is the address of the initialization function. The entry point function is optional for DLLs. When no entry point is present, this member is zero.

A pointer to the beginning of the code section, relative to the image base

PE Header magic numbers

PE Is 32 bit executable

PE is 64 bit executable (PE32+)

PE is a ROM image

Section header Characteristics entry meanings

Reserved for future use

Section should not be padded to next boundary. This is obsolete and replaced by Align1Bytes. This is valid for object files only

Reserved for future use

Section contains executable code

Section contains initialized data

Section contains uninitialized data

Reserved for future use

Section contains comments or other information. The .drectve section has this type. This is valid for object files only

Reserved for future use

Section will not become part of the image. This is valid for object files only

Section contains COMDAT data. This is valid for object files only

Reset speculative exceptions handling bits in the TLB entries for this section

The section contains data referenced through the global pointer

Reserved for future use

Align data on a 1-byte boundary. This is valid for object files only

Align data on a 2-byte boundary. This is valid for object files only

Align data on a 4-byte boundary. This is valid for object files only

Align data on a 8-byte boundary. This is valid for object files only

Align data on a 16-byte boundary. This is valid for object files only

Align data on a 32-byte boundary. This is valid for object files only

Align data on a 64-byte boundary. This is valid for object files only

Align data on a 128-byte boundary. This is valid for object files only

Align data on a 256-byte boundary. This is valid for object files only

Align data on a 512-byte boundary. This is valid for object files only

Align data on a 1024-byte boundary. This is valid for object files only

Align data on a 2048-byte boundary. This is valid for object files only

Align data on a 4096-byte boundary. This is valid for object files only

Align data on a 8192-byte boundary. This is valid for object files only

Section contains extended relocations. The count of relocations for the section exceeds the 16 bits that is reserved for it in the section header. If the NumberOfRelocations field in the section header is 0xffff, the actual relocation count is stored in the VirtualAddress field of the first relocation. It is an error if LnkNrelocOvfl is set and there are fewer than 0xffff relocations in the section

Section can be discarded as needed

Section cannot be cached

Section is not pageable

Section can be shared in memory

Section can be executed as code

Section can be read

Section can be written to

PE File section header

A file pointer to the beginning of the relocation entries for the section. If there are no relocations, this value is zero.

A file pointer to the beginning of the line-number entries for the section. If there are no COFF line numbers, this value is zero.

The number of relocation entries for the section. This value is zero for executable images.

The number of line-number entries for the section.

The characteristics of the image

The total size of the section when loaded into memory, in bytes. If this value is greater than the SizeOfRawData member, the section is filled with zeroes. This field is valid only for executable images and should be set to 0 for object files.

The address of the first byte of the section when loaded into memory, relative to the image base. For object files, this is the address of the first byte before relocation is applied.

The size of the initialized data on disk, in bytes. This value must be a multiple of the FileAlignment member of the Optional header structure. If this value is less than the VirtualSize member, the remainder of the section is filled with zeroes. If the section contains only uninitialized data, the member is zero.

A file pointer to the first page within the COFF file. This value must be a multiple of the FileAlignment member of the Optional header structure. If a section contains only uninitialized data, set this member is zero.

Metadata stream information

ctor

Stream offset in PE file from metadata header

Stream size

Stream name

Optional NT header Subsystem entry meanings

Unknown subsystem.

Image doesn't require a subsystem.

Image runs in the Windows GUI subsystem.

Image runs in the Windows character subsystem.

Image runs in the OS/2 character subsystem.

Image runs in the Posix character subsystem.

Image is a native Win9x driver.

Image runs in the Windows CE subsystem.

An EFI application.

An EFI driver with boot services.

An EFI driver with run-time services.

An EFI ROM image.

XBOX.

A BCD application.

data class to be used to create SdkModule from it.

Path to SDKManifest.xml file

Those content files which are assemblies (not included in ContentFiles hash set)

Content files to be processed (i.e. css, js)

All items including folders

A position in coordinates which corresponds to the end of the usable data in .

1) Allows to create sub-readers for limited length. 2) Caches length to skip re-asking the underlying stream, which for file-based streams saves a lot.

Allows to create sub-readers with zero not at the head of the stream.

Underlying stream. Initial pos, in stream coords. Buf size preference. Logical length of the reader, allows to read a part of the stream. Allows to have a logical zero pos of the reader in the middle of the stream.

Gets the logical position of the reader.

Gets the current physical position of the reader in the underlying stream (stream position itself might differ).

Self-check to make sure that the pre-fetched buffer still corresponds the stream.

Data class which represents an info about a hardware platform, the selected project is applicable to. I.e.'Windows, 8.0' Is necessary to determine which sdk modules might be applicable to the selected project.

Enumerates sdk content roots. Can return nulls. The first enumerated not null value will be the most specific content root.

path to a directory containing sdkManifest.xml file commonConfiguration, retail, debug x64, x86, ARM, neutral Nullable paths. The first enumerated not null value will be the most specific contnet root. Results may be not distinct.

Reads sdk manfest file and fills SdkModuleInfo with sdk content files see http://msdn.microsoft.com/en-us/library/hh768146(v=vs.110).aspx for more information

path to a directory with sdkManifest file most specific path to sdk content files

creates the new instance of SdkModuleInfo

The content root path. Sometimes need to resolve relative path references to js files from html

Ctor

Error Message

Ctor

Error Message Exception that cause PE loading error

Token Value

Token Range

Name of the underlying type

.NET Type names parser

Type Name BNF AQN := FULLNAME := FULLNAME ASSEMSPEC FULLNAME := NAME := NAME QUALIFIERS := NAME GENPARAMS := NAME GENPARAMS QUALIFIERS NAME := T_NAME GENPARAMS := '[' GENARGS ']' QUALIFIERS := QUALIFIER := QUALIFIER QUALIFIERS QUALIFIER := := '*' := '&' := ARRAY ARRAY := '[' ']' := '[' '*' ']' := '[' RANK ']' RANK := := ',' RANK GENARGS := GENARG := GENARG ',' GENARGS GENARG := FULLNAME := '[' EAQN ']' EAQN := FULLNAME := EASSEMSPEC EASSEMSPEC := FULLNAME ',' ASSEMSPEC T_NAME == \d|_[^\.\,\*\&\{\[\}\]\?\<\>]*

Parsing result;

Start state

Assembly qualified name

/* empty */ FULLNAME ',' ASSEMSPEC FULLNAME

Assembly specification

Type fullName

NAME GENPARAMS QUALIFIER

Generic parameters

*empty* '[' GENARGS ']'

Generic argument

GENARG GENARG ',' GENARGS

'[' EAQN ']' FULLNAME

type qualifier

*empty* '&' '*' QUALIFIER ARRAY QUALIFIER

'[' RANK ']' '[' '*' ']'

*empty* ',' RANK

WebCIL file header

WebCIL payload offset

WebCIL analog of JetBrains.Metadata.Utils.PE.SectionHeader, but with fewer fields

Row count for initial metadata table (Generation 0, without EnC delta additional rows)

Row in initial metadata table (no redirects) for token with rid <= GetInitialTableSize, GetInitialTableRow otherwise

E.g. rows in metadata delta TypeDef table have 0 (null) values for MethodList and FieldList => need to use the corresponding values from the original (initial) table

Unique Guid for delta metadata, Guid.Empty for full metadata.

Zero for initial metadata, non-zero for initial metadata combined with EnC deltas.

Offset of the first instruction of the block

Offset of the first instruction following the block

Containing block

Children sorted by start offset

MSIL exception handler record

Exception handler type

IL Code FlowControl enumeration

Instruction redirection

II.7.1: Type ::= ...

II.7.3: TypeReference ::= [ ResolutionScope ] DottedName [ '/' DottedName ]*

II.7.1: ResolutionScope ::= '[' [ .module ] DottedName ']' ('[' .module Filename ']' | '[' AssemblyRefName ']')

II.7.1: TypeSpec ::= ResolutionScope | TypeReference | Type

II.5.3: DottedName ::= Id ['.' Id]* Id ::= ID | SQSTRING

II.5.8: FileName ::= DottedName

II.5.3: Id ::= ID | SQSTRING

Checks whether the s is ID (or ID ['.' ID]* if dotSeparatedIDs) II.5.2: ID is a contiguous string of characters which starts with either an alphabetic character (A–Z, a–z) or one of "_", "$", "@", "`" (grave accent), or "?", and is followed by any number of alphanumeric characters (A–Z, a–z, 0–9) or the characters "_", "$", "@", "`", and "?".

II.5.2: String surrounded by double quote (") marks Within the quoted string the character "\" can be used as an escape character, with "\t" representing a tab character, "\n" representing a newline character, or "\" followed by three octal digits representing a byte with that value. The "+" operator can be used to concatenate string literals. This way, a long string can be broken across multiple lines by using "+" and a new string on each line. An alternative is to use "\" as the last character in a line, in which case, that character and the line break following it are not entered into the generated string. Any white space characters (space, line-feed, carriage-return, and tab) between the "\" and the first non-white space character on the next line are ignored

II.5.2: SQSTRING is just like QSTRING except that the former uses single quote (') marks instead of double

QSTRING or bytearray

II.10.1.7: Generic parameters with attributes and constraints

II.10.1.7: GenPar::= [ [ GenParAttribs ]* [ '(' [ GenConstraints ] ')' ] Id

II.20: SecurityDecl ::= .permissionset SecAction = '(' Bytes ')' | .permission SecAction TypeReference '(' NameValPairs ')'

II.20: SecAction

II.16.2

This presentation should not conflict with the keyword "cf"

II.10.1.6, II.15.4.2.6, II.16.1.4, II.17, II.18

II.17, II.18

II.10: .class ClassHeader '{' ClassMember* '}'

Custom and declarative security attributes and custom attributes of type parameters and type parameters constraints (for a generic type) and custom attributes of interface implementations

Instance layout II.10.2, II.10.7: .pack Int32 | .size Int32

Type (class, value type, or interface) header

II.10.1: ClassAttr*

Option name: JetBrains.ReSharper.ExternalSources.Resources.Strings.DecompileProtectedAssemblies_BoolOption_Text JetBrains.DotPeek.Resources.Strings.Decompile_ProtectedAssemblies_Text

II.15.4.1.3: .locals [ init ] '(' LocalsSignature ')'

Local variable 15.4.1.3: Local ::= [ '[' Int32 ']' ] Type [ Id ]

render variable tuple element names from pdb / decompiler

II.18: .event EventHeader '{' EventMember* '}'

.event EventHeader II.18: EventHeader ::= [ specialname ] [ rtspecialname ] [ TypeSpec ] Id

Render field and custom field attributes II.16: Field ::= .field FieldDecl + associated data (initial value; II.16.3 .data = DataDecl)

.field FieldDecl

II.16: FieldDecl ::= [ '[' Int32 ']' ] FieldAttr* Type Id [ '=' FieldInit | at DataLabel ]

II.16.1: FieldAttr*

II.6.3: .assembly extern DottedName '{' AsmRefDecl* '}' AsmRefDecl ::= .hash '=' '(' Bytes ')' // Hash of referenced assembly, II.6.2.3 | .custom CustomDecl | .culture QSTRING // Culture of the referenced assembly, II.6.2.1.2 | .publickeytoken '=' '(' Bytes ')' // The low 8 bytes of the SHA-1 hash of the originator's public key, II.6.3 | .publickey '=' '(' Bytes ')' // The originator's full public key, II.6.2.1.3 | .ver Int32 ':' Int32 ':' Int32 ':' Int32 // Major version, minor version, build, and revision, II.6.2.1.4

II.6.2: .assembly DottedName '{' AsmDecl* '}' AsmDecl ::= .custom CustomDecl | .hash algorithm Int32 // Hash algorithm used in the .file directive, II.6.2.1.1 | .culture QSTRING // Culture for which this assembly is built, II.6.2.1.2 | .publickey '=' '(' Bytes ')' // The originator's public key, II.6.2.1.3 | .ver Int32 ':' Int32 ':' Int32 ':' Int32 // Major version, minor version, build, and revision, II.6.2.1.4 | SecurityDecl

II.6.4: .module [ Filename ] + commented MVID + custom attributes for module

II.6.5: .module extern Filename + custom attributes for extern module

II.6.2.3: .file [ nometadata ] Filename .hash '=' '(' Bytes ')' [ .entrypoint ] + custom attributes

II.6.2.2: .mresource [ public | private ] DottedName '{' ManResDecl* '}' ManResDecl ::= .assembly extern DottedName // Manifest resource is in external assembly with name DottedName | .custom CustomDecl | .file DottedName at Int32 // Manifest resource is in file DottedName at byte offset Int32

II.6.2.2, II.6.7, II.6.8: .assembly extern DottedName | .file DottedName at Int32 | .file DottedName | .class extern DottedName

II.6.7: .class extern ExportAttr DottedName '{' ExternClassDecl* '}' ExternClassDecl ::= .file DottedName | .class extern DottedName | .custom CustomDecl ExportAttr ::= public | nested public or II.6.8: .class extern forwarder DottedName '{' .assembly extern DottedName '}' + custom attributes for forwarded type

II.6.7, II.6.8 .class extern DottedName (if !detailed) .class extern ExportAttr DottedName .class extern forwarder DottedName

II.6.2.1.1: .hash algorithm Int32 // Hash algorithm used in the .file directive

II.6.2.3: .hash '=' '(' Bytes ')' // Hash of referenced assembly / file

II.6.2.1.2: .culture QSTRING // Culture for which this assembly is built

II.6.2.1.3: .publickey '=' '(' Bytes ')' // The originator's public key

II.6.3: .publickeytoken '=' '(' Bytes ')' // The low 8 bytes of the SHA-1 hash of the originator's public key

II.6.2.1.4: .ver Int32 ':' Int32 ':' Int32 ':' Int32 // Major version, minor version, build, and revision,

Expert .NET 2.0 IL Assembler - ILAsm Grammar Reference - Module Parameter Declaration: moduleParamDecl ::= .subsystem int32 | .corflags int32 | .file alignment int32 | .imagebase int64 | .stackreserve int64 todo: | .typelist { classNameSeq } | .mscorlib | vtableDecl /* deprecated, use .vtfixup instead * / | vtfixupDecl

II.7.4, II.15.4, II.16.1: [ marshal '(' [ NativeType ] ')' ]

II.7.4

II.15: .method MethodHeader '{' MethodBodyItem* '}'

Attributes, entry point, parameters default values and attributes, type parameters and type parameters constraints attributes, implemented methods

II.15.4: MethodName ::= .cctor | .ctor | DottedName

II.15.4.2: MethAttr*

II.15.4.2.5: [ pinvokeimpl '(' QSTRING [ as QSTRING ] PinvAttr* ')' ]

II.15.3: CallConv ::= [ instance [ explicit ]] [ CallKind ] A calling convention specifies how a method expects its arguments to be passed from the caller to the called method. It consists of two parts: the first deals with the existence and type of this pointer, while the second relates to the mechanism for transporting the arguments

II.15.4: '(' Parameters ')'

parameters and type parameters

II.15.4.3: ImplAttr*

II.10.3.2

II.17: .property PropHeader '{' PropMember* '}'

.property PropHeader II.17: PropHeader ::= [ specialname ][ rtspecialname ] CallConv Type Id '(' Parameters ')'

Can be nested: /*parent1/*child*/parent2*/ => /*parent1*//*child*//*parent2*/

Writes single-line comment characters and comment string and automatically marks end of single-line comment

Writes text with single-line comment characters inside it and automatically marks end of single-line comment

Adds new line requirement

MSIL Method body

IL method body flags

Small Code

Tiny code format

Fat code format

Mask for extract code type

Runtime call default constructor on all local vars

there is another attribute after this one

MSIL instruction.

Instruction offset from the method beginning.

Instruction size (in bytes) including the operands.

Instruction opcode.

Polymorphic operand whose exact type depends on .

Provides type-safe utilities for extracting depending on

Target instruction relative offset (from the beginning of the instruction following the current instruction)

Next instruction absolute offset (from the beginning of the method)

Target instruction absolute offset (from the beginning of the method)

Target instruction index in instructions array

Target instructions absolute offsets (from the beginning of the method)

Gets required number of items that should be on stack before execution of this call/callvirt instruction

Gets required number of items that should be on stack before execution of this newobj instruction

Gets required number of items that should be on stack before execution of this calli instruction

Gets required number of items that should be on stack before execution of ret instruction in this method

Gets required number of items that should be on stack before execution of this instruction

Gets number of items that are pushed on stack by this instruction

Gets number of items that should be pushed into stack before execution of this instruction

0 - sequence point associated with this instruction is allowed

MSIL opcode value

Replaces *_i/*_u instructions with theirs specified integer variants depending on is64Bit flag

OpCodes static definitions

OpcodeType enumeration

Operation codes enumeration

Debugging breakpoint

The short-parameter form of br.

Branch if {value} is zero.

Branch if {value} is nonzero

Branch if {value1} is equal to {value2}.

Branch if the two values are not equal. Integer values are interpreted as unsigned

Describes the possible types of .

StackBehaviour enumeration

Accessibility for properties and events (type members that do not have explicit accessibility in metadata) is the maximum accessibility among the accessors Accessibility for properties and events (type members that do not have explicit accessibility in metadata) equals to accessibility of containing type (accessibility of accessors is not taken into account)

Assembly location on disk

Data class to encapsulate source module's path and the referenced assembly name to be resolved

Enables Fusion's resolving assemblies when loading into the current appdomain based on the .

methodName is not null if rendered name differs from method.Name (e.g. methodName is local function name)

NULL if lookup in the real GAC has been disabled, that's required if we're planning on modifying the fusion appdomain assembly resolver, might interfere with loading the proper bitness.

Gets whether the given assembly path is under some GAC location.

The regular GAC, 2.0, 4.0, etc.

Resolve into assemblies of Visual Studio as well. With VS up to 14, its assemblies were installed into the GAC, so it worked the regular way. With VS 15, assemblies are not getting into GAC, but we still expect that our code is able to use VS assemblies on machines which have VS installed.

Searches in gac

Gets whether the given assembly path is under some GAC location.

Favors the specific version number and public key. TODO: should eventually take publisher policies into account.

Prefers the exact match, but also tries to look up a newer assembly with the same name as a fallback. This roughly emulates the “unification” e.g. when we're reading a parts catalog on a machine which only has NetFX4+ installed and cannot load “System.Drawing v2.0” for us.

If the same assembly is present in both GAC20 and GAC40, take the newer one assuming it covers all of the older functionality. This is essential if you're running CLR2 assemblies (with references to v2.0 GAC assemblies) on the new CLR. TODO: take assembly unification into account, as probably not all of the assemblies should be redirected this way

Resolves to .NET Framework runtime assemblies (version 2 and 4 are supported).

Gets whether the given assembly path is under some GAC location.

C# 2.0 spec paragraph 13.1.2; without decimal From sbyte to short, int, long, float, double. From byte to short, ushort, int, uint, long, ulong, float, double. From short to int, long, float, double. From ushort to int, uint, long, ulong, float, double. From int to long, float, double. From uint to long, ulong, float, double. From long to float, double. From ulong to float, double. From char to ushort, int, uint, long, ulong, float, double. From float to double.

Suppresses module to module resolution

Assembly location on disk / file entry inside single file bundle / in memory / etc.

It can be not only an assembly, but also a file of another format (e.g. .runtimeconfig.json file inside bundle) null for file entry inside bundle / assembly in memory bundle file path for file entry inside bundle, null for assembly in memory

Returns AssemblyPhysicalPath if it is not null, extracts assembly to temp file otherwise

lifetime of temporary file temporary file path or AssemblyPhysicalPath

Interface for resolving assembly names to assemblies

Resolves assembly name to assembly metadata interface

Since few implementation relies on internal data, is valid only during single ReadLock session. This returns independent implementation

The main function is to find all presentations of entity using only one presentation, that is: Method specs, defs and refs tokens using or associated with method spec, def or ref. Type specs, defs or refs tokens using or associated with type spec, def or ref. Field defs or refs tokens using or associated with field def or ref.

Returns field defs or refs that corresponds to in this assembly

Array of field defs or refs tokens

Returns type defs, refs or specs that corresponds to in this assembly

Array of type defs, refs or specs tokens

Returns method specs, defs or refs that corresponds to in this assembly

Array of method specs, defs, refs tokens

Find a token that corresponds to in this assembly

TypeDef or TypeRef or Nil

Returns field defs or refs that corresponds to in this assembly

Array of field defs or refs tokens

Returns type defs, refs or specs that corresponds to in this assembly

Array of type defs, refs or specs tokens

Returns method specs, defs or refs that corresponds to in this assembly

Array of method specs, defs, refs tokens

Gets whether the given assembly path is under some GAC location.

Returns method body presentation

Throws if method body reader failed Method body presentation if available, null if no method implementation found

Returns raw method body presentation. Main difference from GetMethodBody is that Instruction's operands are not resolved.

Throws if method body reader failed Raw method body presentation if available, null if no method implementation found

Marker interface to identify array methods

Gets element type

Returns whether this type is vector

Gets array rank

Gets sizes if specified. Note that sizes might be specified not for all dimensions.

Gets low bounds if specified. Note that low bounds might be specified not for all dimensions.

Gets type generated for array

Interface which is used to access metadata of an assembly

Gets assembly name

Gets assembly mvid and size

Gets array of referenced assemblies' names

Gets assembly location

Gets type info from its qualified name

Gets type info from its token

Gets type from its qualified name

Gets array of types defined in the assembly

Gets types exported from other modules (types, defined within OTHER modules of THIS assembly)

Do not confuse this method with System.Reflection.Assembly.GetExportedTypes() method (which returns public types defined in this assembly that are visible outside the assembly)

Gets types forwarded to another assembly (TypeForwardedTo)

Gets manifest resources

Returns new image body reader It opens module for read and closes it upon Dispose

Returns new usages finder Note: It reads module into memory upon creation

Gets array of custom attributes associated with the main module

Determines whether the assembly is protected from disassembly (has SuppressIldasmAttribute attribute on assembly/module)

Entity which stores data about initialized field of a custom attribute

Gets initialized field

Entity which stores data about initialized member (property or field) of a custom or security attribute

Initialized property or field

Type of property or field

Name of initialized property or field

Value the type member (property or field) is initialized with

Entity which stores data about initialized property of a custom attribute

Gets initialized property

A type which corresponds to a type or instance of a generic class

Gets underlying metadata type

Gets type parameters if applicable

Represents a custom attribute

Gets constructor which is used for instantiating the attribute

Used constructor token

Gets array of values passed as arguments to the used constructor

Explicitly initialized properties and fields

Base interface for all metadata entities

Assembly where this entity is located

Gets assembly token

Gets array of custom attributes defined for this metadata entity

Gets array of custom attributes type names (much faster than getting entire custom attributes)

Gets array of attributes having the specified fully qualified name

Checks if an entity has a custom attribute

Returns whether this entity points to existent entity

Represents event metadata

Gets event type

Gets adder method

Gets remover method

Gets raiser method

Gets array of other event methods

Represents field metadata

Gets field type

Gets a marshalling specification if HasMarshalSpec

Gets literal field value

Gets literal field value blob

Field offset in type instance. Non-negative value if specified

Gets the field signature

Gets initial value RVA in case value stored in the image itself, not metadata

Gets flag indicating whether the field has assembly visibility

Gets flag indicating whether the field is private

Gets flag indicating whether the field is public

Gets flag indicating whether the field has family visibility

Gets flag indicating whether the field has family-and-assembly visibility

Gets flag indicating whether the field has family-or-assembly visibility

Gets flag indicating whether the field is static

Gets flag indicating whether the field is readonly

Gets flag indicating whether the field is literal

Gets flag indicating whether the field has associated marshaling spec

Gets flag indicating whether the field must not be serialized

Where the forwarded type is declared (forwarded to)

Forwarded type FQN

Unmanaged pointer to a function (fnptr)

Represents a metadata method

Get the return value (which is encoded as zero-index parameter)

Gets method parameters

Gets array of generic type parameters of this method

Gets array of explicitly implemented methods

Gets method signature

PInvoke mapping if IsPInvokeImpl AND signature was successfully decoded

Gets all impl method flags in one call

Gets flag indicating whether the method has PInvoke implementation

Returns method implementation platform (IL, native code or runtime embedded)

Relative virtual address of method code

Indicates the method is defined; used primarily in merge scenarios.

Indicates method sig is not to be mangled to do HRESULT conversion.

Method is implemented in runtime (?)

Method is single threaded through the body.

Method may not be inlined

Method should be inlined if possible

The method contains code that should always be optimized for performance

Method may not be optimized

Gets flag indicating whether the method has assembly visibility

Gets flag indicating whether the method is private

Gets flag indicating whether the method is public

Gets flag indicating whether the method has family visibility

Gets flag indicating whether the method has family-and-assembly visibility

Gets flag indicating whether the method has family-or-assembly visibility

Gets flag indicating whether the method is static

Gets flag indicating whether the method is abstract

Gets flag indicating whether the method is implemented externally (non-abstract without IL body)

Gets flag indicating whether the method is virtual

Gets flad indicating whether the method can be overridden

Gets flag indicating whether the method hides by name and signature

Gets flag indicating whether the method is newslot

Gets flag indicating whether the method overridability is the same as the visibility

Gets flag indicating whether the method is vararg

Gets flag indicating whether the method is unmanaged

Represents a method parameter

Gets parameter name

Gets parameter type

Gets method which declares this parameter

Gets a marshalling specification if HasMarshalSpec

Gets flag indicating whether the parameter is input

Gets flag indicating whether the parameter is output

Gets flag indicating whether the parameter is parameter array

Gets flag indicating whether the parameter is optional

Gets flag indicating whether the parameter has associated marshaling spec

Gets flag indicating whether the parameter has associated default value

Gets default field value

Unmanaged pointer to a type

Gets nested type

Represents a property metadata

Gets property type

Gets getter method

Gets setter method

Gets all property accessors

Managed pointer to a type

Gets nested type

Represents a method return value (which is encoded as zero-index parameter)

Gets method which declares this parameter

Gets parameter type

Gets a marshalling specification if HasMarshalSpec

Gets flag indicating whether the parameter has associated marshaling spec

Explicitly initialized properties and fields

Not decoded attribute constructor arguments

We don't know which constructor is used for creating this attribute (in contrast to custom attribute), therefore we don't know parameters types => can't properly decode arguments

In the normal case it should be equal to DeclaringSecurityRow.Action

DeclSecurity rows

Qualified names of security attributes

Gets flag indicating whether the method has security attributes

Represents a type in metadata. Use as comparer

Gets type presentable name

Gets array of modopts and modreqs

Interface for accessing types metadata

Gets fully qualified name of the type

Gets assembly qualified name of the type

Gets namespace of the type.

Gets name of the type. For nested types, it is the combination of (owner name + Name)

Assembly name (if any) where this type is located

Gets base type

Returns null if there is no base type

Gets array of interface implementations (interface and associated custom attributes, e.g. TupleElementNamesAttribute, NullableAttribute) for this type

Gets array of generic type parameters of this type

Gets flag indicating whether the type is abstract

Gets flag indicating whether the type is imported

Fields layout type

Charset for pinvoke calls

Gets flag indicating whether the type instructs the CLI that it need not initialize the type before a static method is called

Gets flag indicating whether the type is a class type

Gets flag indicating whether the type is an interface

Gets flag indicating whether the type is serializable

Gets flag indicating whether the type is Windows Runtime type

Gets flag indicating whether the type is public

Gets flag indicating whether the type is not public

Gets flag indicating whether the type is a nested of any type (i.e. any of IsNested* is true)

Gets flag indicating whether the type is a nested public type

Gets flag indicating whether the type is a nested private type

Gets flag indicating whether the type is a nested family type

Gets flag indicating whether the type is a nested assembly type

Gets flag indicating whether the type is a nested family-and-assembly type

Gets flag indicating whether the type is a nested family-or-assembly type

Packing size for layout process. Positive value if specified

Class size. Positive value if specified

Get the names of all members (except of nested type names). This is fast, not decoding

Gets type methods

Gets type fields

Gets type properties

Gets type events

Gets nested types

Gets member name

Gets type which declares the member. Always null for top-level types

Gets flag indicating whether the member has special name flag

Gets flag indicating whether the member has runtime special name flag (name shall be treated in a special way by the runtime)

Represents a generic type parameter

Gets type parameter kind: whether it is owned by a type or by a method

Gets type parameter name

Gets generic type parameter index

Gets type owner, if the type parameter belongs to a type

Gets method owner, if the type parameter belongs to a method

Gets type parameter type constraints, if specified

Gets type parameter attributes

A type which is unbound reference to a generic type parameter

Gets referenced generic type parameter

Owner

Sequence number in method local variables list

Local variable type

Find usages of in method bodies of current assembly (one IMethodBodyUsagesFinder was created from).

Find explicit usages of in method bodies of current assembly (one IMethodBodyUsagesFinder was created from). Be aware of usage count is unknown because it is highly depends of decomplication.

Covered cases of explicit type usage in method body: typeof (including generic instantiation, modreq, modopt, function pointers), calls of type's static methods and constructors, accessing static fields, casts to type, catch arguments, local variables types

Find usages of in method bodies of current assembly (one IMethodBodyUsagesFinder was created from).

Find all methods and usage count containing ldstr instruction with userStringToken operand

Find usages of default constructor of value type in method bodies of current assembly (one IMethodBodyUsagesFinder was created from).

Find all methods containing initobj instruction with typeInfo.Token operand

Presentable name for diagnostic issues

If we're resolving the reference as originated in some assembly, specifies that assembly. This is useful both for diagnostics and for looking up assembly files in folders nearby the originator.

Unified information about type member

Name of the type member

Member token

Determines whether the assembly is protected from disassembly (has SuppressIldasmAttribute attribute on assembly/module)

Gets flag indicating whether the field has volatile modifier

Manages metadata loading. Note: loading assembly into metadata loader holds assembly metadata for loader lifetime. It's a bad idea to hold loader for your product lifetime.

Load assembly with the specified name

Allows to listen to non-fatal metadata reader errors, such as unresolved type. Such errors are expected to happen when you're reading just one assembly without resolving its references, thus they're not reported to the logger as regular exceptions. You can opt in for receiving such error notifications.

A custom implementation of events: allows to know if there're any sinks at all, so that not to fire / prepare eventargs when nobody is listening. This is critical for good PSI performance.

Fires when a Custom Attribute cannot be entirely deserialized. You cannot read the CA stream to the end without additional info, which info you must get from external assemblies. If those are missing or walking into references is not allowed, you cannot parse the stream because the records size cannot be determined (for values of an Enum type, their size is not specified, you must load the assembly declaring the enum type to read even the knonw arguments).

Fires when an implicit assembly reference is encountered — i.e. to parse metadata, we have to load an external assembly which is not explicitly listed in assembly references. An example is reading of the Custom Attribute stream, which might include string representations of assembly-qualified type names pointing to other assemblies. If such assemblies are only used in CA parameters, they would yield no typeref tokens (only a plaintext representation), and CSC would optimize away the assembly references to them.

Fires when a type reference cannot be resolved. Put aside external calls into assembly thru public API, there're two major cases for internal calls from metadata entities of the assembly: (1) MetadataToken.TT_TYPEDEF or MetadataToken.TT_TYPEREF token resolution. (2) Resolution of a string representation of an assembly-qualified type reference (e.g. a type of the named actual parameter in Custom Attribute stream). In the latter case, you're getting as well.

CA Type. The assembly in which the CA BLOB we are trying to decode sits. An explanation what exactly happened. Note that full context info (like what and where) is dumped into exception data, and common message is added by this class, so this must specifically explain the nature of failure. If known, the metadata token of the entitiy (belonging to ) to which the custom attribute (whose blob we are decoding) is applied. Token of the CA itself whose BLOB is being decoded (unless we only got the blob).

CA Type.

The assembly in which the CA BLOB we are trying to decode sits.

An explanation what exactly happened. Note that full context info (like what and where) is dumped into exception data, and common message is added by this class, so this must specifically explain the nature of failure.

If known, the metadata token of the entitiy (belonging to ) to which the custom attribute (whose blob we are decoding) is applied.

Token of the CA itself whose BLOB is being decoded (unless we only got the blob).

assembly qualification, if available.

Tuples are considered equal if they have the same names and types of components

Compares two metadata types. Note: generic argument references are compared by kind and index, not actual generic argument entity they are resolved to. modopt's and pinned are ignored, modreq's are not.

C# 2.0 spec paragraph 13.1.2 From sbyte to short, int, long, float, double, or decimal. From byte to short, ushort, int, uint, long, ulong, float, double, or decimal. From short to int, long, float, double, or decimal. From ushort to int, uint, long, ulong, float, double, or decimal. From int to long, float, double, or decimal. From uint to long, ulong, float, double, or decimal. From long to float, double, or decimal. From ulong to float, double, or decimal. From char to ushort, int, uint, long, ulong, float, double, or decimal. From float to double.

Mainly for decompiler purposes

See Partition I, 8.2.4 and Partition III, 1.8.1.1.

An input type to be boxed. The boxed type.

{ typeInfo.GetTypeOwnTypeParameters().Length, typeInfo.DeclaringType.GetTypeOwnTypeParameters().Length, typeInfo.DeclaringType.DeclaringType.GetTypeOwnTypeParameters().Length, ...}

GenericType<T1, T2>.NestedGenericType<T3> => {1, 2}

Reference to type. Name of the type and assembly where it is declared

Assembly name

Namespace name of the type

Name of the type without namespace For nested types, it is the combination of (owner name + name)

Name of the type

Returns type size in memory or 0 if can't be calculated for sure

mscorlib-like assembly, not always exactly mscorlib

Signature comparison using parameter/return types comparison with ignoring assembly names

Type comparison ignoring assembly names

System.Collections.IDictionary<System.String, System.String> from mscorlib 2.0.0.0 and from mscorlib 4.0.0.0 are considered equal

Count of occurrences of something in IL code. -1 means unknown count (for example

use this constructor only if usage count is unknown

Gets whether the given assembly path is under some GAC location.

Searches in gac

Gets whether the given assembly path is under some GAC location.

No information. E.g. when in '#nullable disable annotations' context or old assemblies without nullable attributes

Type is located in '#nullable enable annotations' context and doesn't have the '?' annotation E.g. string, int, T (including the case when T is unconstrained and can contain null values) Note that this annotation doesn't mean that an expression with it doesn't have null values because of unconstrained generics You need to use IType.GetValueNullableAnnotation method to get this expression's RValue nullability

Explicitly set by flow analysis. It thought to be NotAnnotated by the compiler. However, this value is obtained via type inference from unannotated code, we might want to consider its nullability less strict as NotAnnotated for the purposes of data flow analysis, e.g. we might not want to recommend changing T? to T if the variable might store NotAnnotatedFlowUnknown

Type is located in '#nullable enable annotations' context and have a '?' annotation E.g. string?, T? where T : class; int?, T? where T : struct

Explicitly set by flow analysis. Expression with this type does not contain null values according to the flow analysis even if its annotation allows it.

Explicitly set by flow analysis. Expression with this type definitely doesn't contain null values and this is enforced by actual runtime checks performed in code.

Explicitly set by flow analysis. Expression with this type might contain null values according to the flow analysis even if its annotation doesn't allow it

Explicitly set by flow analysis. Value comes from unannotated API with [CanBeNull] attribute or doesn't have attributes and the analysis is in pessimistic mode It thought to be NotNullable by the compiler. However we might want to produce warnings and shouldn't suggest removing null checks or annotations for expressions of these types

Explicitly set by flow analysis. Value from unannotated API with [NotNull] attribute or doesn't have attributes and the analysis is in implicit notnull mode It thought to be NotNullable by the compiler. We can safely suggest removing null checks and annotations for expressions with these types

Explicitly set by flow analysis. It thought to be NotNullable by the compiler. However, it comes from unannotated API so we might want to produce warnings and shouldn't suggest removing null checks or annotations for expressions of these types

Explicitly set by flow analysis. It thought to be Nullable by the compiler. However, ReSharper analysis thinks that the value cannot be nullable e.g. because it's checked via an assertion not recognized by the compiler

Native method supports C style last error querying (Microsoft implementation of the CLI on MS Windows)

Indicates that the name in the DLL should be used precisely as specified, rather than attempting to add A (for ascii) or W (widechar) to find platform-specific variants based on the type of string marshalling requested (Microsoft implementation of the CLI on MS Windows)

The values 0–0xFF are reserved for future standards use. Values 0x20–0x7F and 0x100–0x07FF are for uses where the action can be ignored if it is not understood or supported. Values 0x80–0xFF and 0x0800–0xFFFF are for uses where the action shall be implemented for secure operation; in implementations where the action is not available, no access to the assembly, type, or method shall be permitted. VS 16.7.x compiler

See Paritition I, 10.3.2.

VS 16.7.x compiler

Resolver used in specific cases, such as when an assembly is in RAM or on the remote server (an extreme case, I recommend that you first download it into RAM). In general nothing can stop you from using file streams.
The created with this resolver will have is .

The theoretical list of all which can be resolved to .

Use this constructor only if you want specify . Otherwise, maybe this constructor is fine for you.

Stream opening functions. Same as MetadataTypeEx.IsEqualTo if both types are resolved; compares FQN for unresolved types Same as MetadataEx.IsConstructor if method is resolved Same as MetadataEx.IsOperator if method is resolved Same as MetadataEx.IsClassConstructor if method is resolved

See Partition II, 12.2.

Compound resolver. Tries to resolve the assembly thru all of the given resolvers, in order of appearance.

II.23.3 Custom attributes

Safeguard from some deep-down method returning a BAD VALUE without marking it as a failed result.

This method can be used to read the single argument of attribute constructor in case the type of this argument cannot be resolved, but the type of this argument is known to be enum with int as an underlying type

Scopes of local variables hoisted to state machine fields

The default namespace for the module/project

VB compiler

IL offset of catch handler or -1

Set of IL offsets where await operators yield control

Set of IL offsets where await operators are to be resumed

Unique identification of an emitted entity (method, lambda, closure) used for debugging purposes (EnC).

When used for a synthesized method the ordinal and generation numbers are included its name. For user defined methods the ordinal is included in Custom Debug Information record attached to the method.

The index of the method in member list of the containing type, or if undefined.

The EnC generation the method was defined in (0 is the baseline build).

Debug information maintained for each lambda.

The information is emitted to PDB in Custom Debug Information record for a method containing the lambda.

The syntax offset of the syntax node declaring the lambda (lambda expression) or its body (lambda in a query).

The ordinal of the closure frame the lambda belongs to, or if the lambda is static, or if the lambda is closed over "this" pointer only.

Id that associates an emitted user-defined or long-lived synthesized local variable with a syntax node that defined it. If a syntax node defines multiple variables it provides information necessary to identify which one of these variables is it.

We calculate a "syntax offset" for each user-defined and long-lived synthesized variable. Every such variable symbol has to be associated with a syntax node (its declarator). In usual cases this is the textual distance of the declarator from the start of the method body. It gets a bit complicated when the containing method body is not contiguous (constructors). If the variable is in the body of the constructor the definition of syntax offset is the same. If the variable is defined in a constructor initializer or in a member initializer (this is only possible when declaration expressions or closures in primary constructors are involved) then the distance is a negative sum of the widths of all the initializers that succeed the declarator of the variable in the emitted constructor body plus the relative offset of the declarator from the start of the containing initializer.

If a single node is a declarator for multiple variables of the same synthesized kind (it can only happen for synthesized variables) we calculate additional number "ordinal" for such variable. We assign the ordinals to the synthesized variables with the same kind and syntax offset in the order as they appear in the lowered bound tree. It is important that a valid EnC edit can't change the ordinal of a synthesized variable. If it could it would need to be assigned a different kind or associated with a different declarator node.

Name of the metadata file (includes an extension)

Comma-separated list of external aliases for the reference. May be empty

0b0000001 - Embed interop types 0b0000010 - The referenced file is an assembly (as opposed to a netmodule)

PE COFF header Timestamp field

PE COFF header SizeOfImage field

Module Version Id (Module metadata table field)

The offset of the first operation in the scope.

The offset of the first operation outside of the scope, or the method body length.

Kind of a synthesized local variable.

Synthesized local variables are either 1) Short-lived (temporary) The lifespan of an temporary variable shall not cross a statement boundary (a PDB sequence point). These variables are not tracked by EnC and don't have names. 2) Long-lived All variables whose lifespan might cross a statement boundary (include a PDB sequence point) must be named in a build configuration that supports EnC. Some of them might need to be named in release, to support EE. The kind of such local must be encoded in the name, so that we can retrieve it from debug metadata during EnC. The integer value of the kind must match corresponding Dev11/12 TEMP_KIND enum values for compatibility with assemblies generated by the native compiler. Long-lived local variables must be assigned slots in source order.

Temp created for caching "this". Technically it is long-lived, but will happen only in optimized code.

Temp created for pattern matching by type.

Temp variable created by the optimizer.

Temp variable created during lowering.

Temp variable created by the emitter.

The variable is not synthesized (C#, VB).

Local variable that stores value of an expression consumed by a subsequent conditional branch instruction that might jump across PDB sequence points. The value needs to be preserved when remapping the IL offset from old method body to new method body during EnC. A hidden sequence point also needs to be inserted at the offset where this variable is loaded to be consumed by the branch instruction. (VB, C#).

Boolean passed to Monitor.Enter (C#, VB).

Variable holding on the object being locked while the execution is within the block of the lock statement (C#) or SyncLock statement (VB).

Local variable that stores the resources to be disposed at the end of using statement (C#, VB).

Local variable that stores the enumerator instance (C#, VB).

Local variable that stores the array instance (C#, VB?).

Local variables that store upper bound of multi-dimensional array, for each dimension (C#, VB?).

Local variables that store the current index, for each dimension (C#, VB?).

Local variable that holds a pinned handle of a string passed to a fixed statement (C#).

Local variable that holds the object passed to With statement (VB).

Local variable used to store the value of Select Case during the execution of Case statements.

Local variable that stores the return value of an async method.

VB: Stores the return value of a function that is not accessible from user code (e.g. operator, lambda, async, iterator). C#: Stores the return value of a method/lambda with a block body, so that we can put a sequence point on the closing brace of the body.

Very special corner case involving filters, await and lambdas.

Local variable that stores the current state of the state machine while MoveNext method is executing. Used to avoid race conditions due to multiple reads from the lifted state.

Local that stores an expression value which needs to be spilled. This local should either be hoisted or its lifespan ends before the end of the containing await expression.

Local variable that holds on the display class instance.

Local variable used to cache a delegate that is used in inner block (possibly a loop), and can be reused for all iterations of the loop.

Local variable that stores the result of an await expression (the awaiter object). The variable is assigned the result of a call to await-expression.GetAwaiter() and subsequently used to check whether the task completed. Eventually the value is stored in an awaiter field. The value assigned to the variable needs to be preserved when remapping the IL offset from old method body to new method body during EnC. If the awaiter expression is contained in an active statement and the containing MoveNext method changes the debugger finds the next sequence point that follows the await expression and transfers the execution to the new method version. This sequence point is placed by the compiler at the immediately after the stloc instruction that stores the awaiter object to this variable. The subsequent ldloc then restores it in the new method version. (VB, C#).

Stores a dynamic analysis instrumentation payload array. The value is initialized in synthesized mehtod prologue code and referred to throughout the method body.

All values have to be less than or equal to

An awaiter in async method. Never actually created as a local variable, immediately lifted to a state machine field.

The receiver of a delegate relaxation stub. Created as a local variable but always lifted to a relaxation display class field. We never emit debug info for hoisted relaxation variable.

Returns field defs or refs that corresponds to in this assembly

Array of field defs or refs tokens

Returns type defs, refs or specs that corresponds to in this assembly

Array of type defs, refs or specs tokens

Find a token that corresponds to in this assembly

TypeDef or TypeRef or Nil

Returns method specs, defs or refs that corresponds to in this assembly

Array of method specs, defs, refs tokens

Logs assembly resolution failures. If adding to , must be the last one.

Reports the error on assembly resolve, in case no errors have been reported for the same assembly yet.

More info for the resolve originator. Does not take part in Distinct.

Partition II Metadata 23.2.4: FieldSig

Resolves to the assemblies in the currently loaded appdomain. Not threadsafe.

Gets "pointer" to the resource location, independent of ImageBodyReader

Reads field and property initializations and not decoded attribute constructor arguments

indicates alternative format of named arguments number not decoded attribute constructor arguments or null Attribute blob bytes: [attributeBlobStartPosition, attributeBlobEndPosition) = [attributeBlobStartPosition, attributeBlobEndPosition - 1]

Blob bytes: [fromPosition, toPosition) = [fromPosition, toPosition - 1]

Partition II Metadata 23.2.5: PropertySig