Index

images  A

A::Bar method

A::Baz method

abstract keyword

abstract method, Implementation flags

abstract type semantics flag

abstract virtual methods

Accessibility flags

AddressOfCallBacks field

AddressOfFunctions field, IMAGE_EXPORT_DIRECTORY

AddressOfIndex field

AddressOfNameOrdinals field, IMAGE_EXPORT_DIRECTORY

AddressOfNames field, IMAGE_EXPORT_DIRECTORY

A::Foo method

_AGGRESIVE_WS_TRIM flag

Aliasing

field keyword

method keyword

.namespace directive

Simple3.il

.typedef keyword

alphanumeric characters

ansi bstr native type

ansi string formatting flags

AppBase

AppDomain-bound objects

application base (AppBase)

application configuration file

application domain

Architecture data address

arglist instruction

<arg_type> value

Arithmetical instructions

arithmetical operations

bitwise operations

block operations

constant loading

conversion operations

conv.r.un operation

object references

indirect loading

indirect storing

logical condition check instructions

overflow arithmetical operations

overflow conversion operations

shift operations

stack manipulation

dup instruction

nop instruction

pop instruction

arrays

ASMMETA tool

Assembly(ies)

assembly accessibility flag

Assembly declaration

.assembly extern directive

Assembly Linker tool

Assembly metadata table and declaration

assembly method, Accessibility flag

AssemblyRef declarations

Assembly Reference metadata item

AssemblyRef metadata table and declaration

Bar method

BuildNumber

Flags

HashValue

Locale

.locale directive

MajorVersion column

MinorVersion

Name

PublicKeyOrToken

.publickeytoken directive

RevisionNumber

AssemblyRef token

AsyncCallback delegate

asynchronous calls

attributes, class

class layout information

class references

class visibility and friend assemblies

flags

interface implementations

overview

parent of type

augmentation

class

segments

autochar string formatting flags

auto keyword

auto layout flag

images  B

base address conflict

Base entry, Export Directory table

Base field, IMAGE_EXPORT_DIRECTORY

Base Relocation table address

B::BarBaz method

B::Bar method

B::Baz method

B::Foo method

beforefieldinit flag

beforefieldinit type implementation flags

BeginInvoke method

BeginInvoke thread starter

binary flag entries

Binary flags

binding

binpath

_32BIT_MACHINE flag

32BITREQUIRED flag

32-bit specific assemblies

blittable

#Blob stream

Boolean constants

Boolean variable

bool get_IsCompleted() method

bool type

Bound Import table address

boxed values

boxing

Break instruction

bstr native type

BuildNumber column

bytearray

Unicode characters

var data type

4-byte integer type

_BYTES_REVERSED_HI flag

_BYTES_REVERSED_LO flag

images  C

call instruction

callmostderived flag

callvirt instruction

C++ compiler

.cctor invocation schedule

.cctor keyword

.cctor method

Certificate table address

Characteristics field

IMAGE_EXPORT_DIRECTORY

IMAGE_SECTION_HEADER structure

char type

char* var data type

cil method, Code type

circular dependencies, resolving

class augmentation

class constructor

class declarations

Class entry, MemberRef metadata table

.class extern directive

Classes

class attributes

class layout information

class references

class visibility and friend assemblies

flags

interface implementations

overview

parent of type

class augmentation

class metadata

ClassLayout metadata table

InterfaceImpl metadata table

NestedClass metadata table

type definition (TypeDef)

TypeDef metadata table

type reference (TypeRef)

TypeRef metadata table

delegates

enumerations

full class names

interfaces

nested types

representing in signatures

value types

boxed and unboxed values

derivation of value types

instance members of value types

overview

class flags

class identifier (CLSID)

Class index, TypeDef table

class interface

class layout

class layout information

ClassLayout metadata table

class leaf

Class method, MethodImpl table

class names

class references

ClassSize entry

<class_str> parameter

class type

_CNT_CODE flag

_CNT_INITIALIZED_DATA flag

_CNT_UNINITIALIZED_DATA flag

coclass

CodeBase

code base (CodeBase)

Code enhancement

compacting

check method

disassembler and assembler

Idloc Retval instruction

ILAsm compiler

ldc.i4 instruction

OddOrEven sample application

protection

console output method

high-level language compilers

leave instruction

pop and ldnull instruction

Simple2.il modification

structured exception handling

.try-catch protection

try/guarded block

Code management

Code type

COFF header

colon character (INSERT-COLON-HERE)

COMIMAGE_FLAGS_32BITREQUIRED bit flags

COMIMAGE_FLAGS_32BITREQUIRED flag

COMIMAGE_FLAGS_IL_LIBRARY bit flags

COMIMAGE_FLAGS_ILONLY bit flags

COMIMAGE_FLAGS_ILONLY common language runtime header flag

COMIMAGE_FLAGS_NATIVE_ENTRYPOINT bit flags

COMIMAGE_FLAGS_STRONGNAMESIGNED bit flags

COMIMAGE_FLAGS_TRACKDEBUGDATA bit flags

Command-line options

IL assembler

option key

source file extension (.il)

IL disassembler

File/console Output option (PE Files Only)

File Output option (PE Files Only)

ILAsm Code-Formatting option (PE Files Only)

metadata option

output redirection option

command-line options, ILAsm compiler

Common intermediate language (CIL)

Common language runtime (CLR)

abstract intermediate representation

assemblies

garbage collection

install-time code generation

loader and JIT compiler

managed code

managed executables

metadata

modules

.NET-oriented compilers

NGEN utility

overview

primitive types in

data pointer types

function pointer types

modifiers

native types

overview

primitive data types

variant types

vectors and arrays

structured exception handling

type control

common language runtime header

data constants

data sections

EntryPointToken field

Flags field

header structure

managed resources

overview

relocation section

resources

StrongNameSignature field

text section

thread local storage

unmanaged export table

unmanaged resources

v-table

VTableFixups field

Common language runtime header address

Common Language Specification (CLS)

Compilation control directives

#define SYM1

#define SYM2 “SomeText”

#else

#endif

#ifdef SYM

#ifndef SYM

#include “MyHeaderFile.il”

Simple4.il

#undef SYM1

compiling in debug mode

composite (dotted) name

configuration files

Constant metadata

Constant metadata table

constants

Constant table

constrained virtual calls

managed pointer

object reference

constraints

constructors

class constructors

and beforefieldinit flag

module constructors

overview

data constants

instance constructors

contents

Context-bound objects

Contract flags

<cookie_str> parameter

CorCallingConvention enumeration

CorElementType enumeration

CorFieldAttr enumeration

CorHdr.h header file

CorMethodAttr enumeration

CorMethodImpl enumeration

CorNativeType enumeration

CorParamAttr enumeration

CorUnmanagedCallingConvention enumeration

COR_VTABLE_32BIT flag

COR_VTABLE_64BIT flag

COR_VTABLE_CALL_MOST_DERIVED flag

COR_VTABLE_FROM_UNMANAGED flag

cross-domain communications

C# support method

C++ support method

CSV suboption, <met_opt>

.ctor keyword

.ctor method

culture

Current class

.base keyword

DEFLT_CTOR symbol

keywords

.nester keyword

.this keyword

Custom attributes

AllowMultiple Boolean property

assembly linker

namespace System.Reflection

System.Runtime.CompilerServices.AssemblyAttributesGoHere class

AttributeUsageAttribute

common language specification (CLS) compliance

CLSComplianceAttribute

ObsoleteAttribute

CustomAttribute table

parent entry

Type entry

Value entry

declaration

attribute declaration

class reference

code snippet

hypothetical custom attribute

IEnumerable interface

ILAsm directives

IL disassembler

instance constructor

InterfaceImpls

item declaration

StandAloneSigs

verbal value description

DeclSecurity metadata records

definition

enumeration

execution engine and JIT compiler

System.Diagnostics.DebuggableAttribute

System.Security.UnverifiableCodeAttribute

System.ThreadStaticAttribute

globally unique identifier (GUID)

inherited Boolean property

interface description language (IDL)

interoperation subsystem

ComAliasNameAttribute

ComConversionLossAttribute

ComRegisterFunctionAttribute

ComSourceInterfacesAttribute

ComUnregisterFunctionAttribute

ComVisibleAttribute

DispIdAttribute

GuidAttribute

IDispatchImplAttribute

ImportedFromTypeLibAttribute

InterfaceTypeAttribute

ProgIdAttribute

TypeLibFuncAttribute

TypeLibTypeAttribute

TypeLibVarAttribute

interoperation subsystem ClassInterfaceAttribute

metadata validity rules

overview

pseudocustom attributes

reflection methods

remote procedure call (RPC)

remoting subsystem

instance constructors

synchronization requirement flags

System.Runtime.Remoting.Activation.UrlAttribute attribute, TypeDef

System.Runtime.Remoting.Contexts.ContextAttribute attribute, TypeDef

System.Runtime.Remoting.Contexts.SynchronizationAttribute attribute, TypeDef

security attributes

SuppressUnmanagedCodeSecurityAttribute

System.AttributeUsageAttribute

System.Security.Permissions namespace

TypeDef

Value blob encoding

byte sequence

common language runtime

ILAsm notation

prolog

Reflection conventions

resolution scope

serialization code

serialization type codes

SERIALIZATION_TYPE_ENUM

unsigned int16 values

UTF-8 encoding

verbal description

field keyword

keyword object

property keyword

serialized primitive type

serialized type

string

Visual Studio debugger

images  D

data constants See also fields and data constants, 167

common language runtime header

data directory table

<data_label> nonterminal symbol

data pointer types

data sections

& data type

<data_type> nonterminal symbol

Debug data address

DebuggableAttribute attribute

debug mode, compiling in

_DEBUG_STRIPPED flag

declarations

default flag value

default values

defined type

Defining integer

Delay import descriptor address

delegate(s)

Delegate interface

dependencies

derivation of value types

disassembly text

_DLL flag

DllMain function

dotted names

<dotted_name> value

double pointers

DWORD entry

DynamicInvoke method

images  E

Ecma InternationalINSERT-FORWARDSLASH-HEREISO standard specification

EH clause

internal representation

binary flags

entries

fat header

leave instruction

section header

small header

label form declaration

filter handlers/catch handlers

finally handlers/fault handlers

handler <label> to <label> code

lexical order

.try <label> to <label> code

scope form declaration

filter clause

IL disassembler

nested EH configuration

structuring rules

types

0x0000 value

0x0001 value

0x0002 value

0x0004 value

element address loading

controlled mutability managed pointer

readonly. instruction

EncBaseId column

EncId column

EnclosingClass index

encoded types

EndAddressOfRawData field

EndInvoke method

EntryPointToken

EntryPointToken entry

EntryPointToken field

enumeration

enum(s)

flag

semantics pseudoflags

equality character (=)

E_T_FNPTR type

Events

delegates

CombineImpl instance method

event listeners

event sinks

invoke method

RemoveImpl

source/publisher

subscribers

System.Delegate method

System.Threading.WaitHandle class

virtual methods

event declaration

event metadata

EventMap table

Event table

MethodSemantics table

Exception handling

EH clause (see EH clause)

exception types

execution engine exceptions

interoperability exceptions

JIT compiler exceptions

loader exceptions

subclassing exceptions

unmanaged exception mapping

platform invocation mechanism

processing exceptions

application execution

endfilter instruction

endfinally instruction

execution engine

filter block

rethrow instruction

stack evolutions

TryLength entry, EH Clause

TryOffset entry, EH Clause

structured exception handling (SEH) mechanism

Exception table address

_EXECUTABLE_IMAGE flag

executables (EXE files)

explicit layout

explicit layout flag

explicit method overriding

explicit modifier

explicit type layout

Export Address table (EAT)

Export Directory table

Export Directory table address

ExportedType declarations

ExportedType metadata table and declaration

ExportedType table

Export Name table (ENT)

exposed items

extends clause

extends leaf

Extends token

images  F

famandassem accessibility flag

famandassem method, Accessibility flag

family accessibility flag

family method, Accessibility flag

famorassem accessibility flag

famorassem method, Accessibility flag

Fat Header structure

field declaration

Field Definition (FieldDef) metadata item

Field entry

FieldLayout metadata table

FieldRVA table

field initialization

field keyword

FieldLayout metadata table

FieldLayout table

FieldList entry

FieldList index

field mapping

FieldRVA records

FieldRVA table

fields and data constants

constructors vs. data constants

data constants declaration

default values

explicit layouts and union declaration

field metadata

defining Field

overview

referencing Field

global fields

instance and static fields

mapped fields

overview

field signatures

Field table

field token

File declarations

file directive

File metadata table and declaration

file reference (File)

Finalize method

final method, Contract flag

Fixup table

flags

method flags

binary flag entry

Flags column

Flags entry

Method parameter

Method table

Flags field

float32 data type

float64 data type

floating-point format

Foo class

forward class declaration

forwarder RVA

forwardref method

friend assemblies

fromunmanaged flag

full class names

function pointer

images  G

Garbage collection

garbage collection (GC) subsystem

GC heap

Generation column

Generic methods

calling

function pointer

instantiation

ILAsm notation

class constructors (.cctor)

<flags> clause

“<gen_params> clause”

instance constructors (.ctor)

instance methods

metadata

GenericParamConstraint table

MethodSpec table

overriding methods

abstract virtual method

Gen_virt.il

type parameters

void A<T>() method

void B<U>() method

overview

signatures

ILAsm notation

IMAGE_CEE_CS_CALLCONV_GENERIC

method calling conventions

vararg generic methods

static methods

Generic types

addressing type parameters

concrete types

constraint(s)

constraint flags

C++ templates

cyclic dependencies

environments

expanding edge

extends clauses

ILAsm

GenericParamConstraint table

<gen_params> clause

implements clauses

inheritance

instantiation(s)

class keyword

ILAsm syntax

type arguments

type parameters

TypeSpecs

Instantiation dependency graph

interface implementation

members

parent type

vararg calling convention

virtual methods

metadata

generic arity

GenericParamConstraint table

GenericParam table

generic signature

ILAsm code

type definition (TypeDef)

type parameters

type reference (TypeRef)

type specification (TypeSpec)

TypeSpec metadata table

nested

C# compiler

ILAsm code

T type parameter

nonexpanding edge

parameterized types

parameter list

type variables

vectors

get_AsyncWaitHandle interface

GetNextArg method

GetRemainingCount method

GetRemainingCount return value

Global assembly cache (GAC)

global fields

Global pointer

GotDotNet

govern class augmentation

Grammar reference

aliasing types

class declaration

class body declarations

generic type parameters

class referencing

compilation control directives

constant declarations

custom attribute declarations

data declaration

event declaration

field declaration

lexical tokens

manifest declarations

method and field

method declaration

external source directives

IL instructions

managed exception

method body

module-level declarations

module parameter declaration

nonterminals

data type

identifier

property declaration

security declarations

signatures

managed types

native types

images  H

HashAlgId column

hash blob

HashValue column

header structure

HEA suboption, <met_opt>

heuristics

HEX suboption, <met_opt>

hidebysig method, Contract flag

HRESULT returns

images  I

identifier

identity

IDispatch flag

ILAsm compiler

ILAsm naming conventions

ILAsm notation

ILAsm source code

ILAsm syntax

IL assembler

IL assembly language (ILAsm)

class declaration

CLR (see Common language runtime (CLR))

OddOrEven sample application

calling unmanaged code

class declaration

data declaration

field declaration

global items

mapped fields

method declaration

program header

value type as placeholder

IL disassembler (ILDASM)

IL inlining in high-level languages

IL instruction set

parameterand stack operations

parameter types

stack types

ILLINK

ILONLY flag

IMAGE_CEE_CS_CALLCONV_DEFAULT method

IMAGE_CEE_CS_CALLCONV_EXPLICITTHIS method

IMAGE_CEE_CS_CALLCONV_FIELD field

IMAGE_CEE_CS_CALLCONV_HASTHIS instance method

IMAGE_CEE_CS_CALLCONV_LOCAL_SIG local variable

IMAGE_CEE_CS_CALLCONV_PROPERTY property

IMAGE_CEE_CS_CALLCONV_UNMGD unmanaged calling convention

IMAGE_CEE_CS_CALLCONV_VARARG method

IMAGE_CEE_UNMANAGED_CALLCONV_C calling convention

IMAGE_CEE_UNMANAGED_CALLCONV_FASTCALL calling convention

IMAGE_CEE_UNMANAGED_CALLCONV_STDCALL calling convention

IMAGE_CEE_UNMANAGED_CALLCONV_THISCALL calling convention

IMAGE_REL_BASED_ABSOLUTE relocation type

IMAGE_REL_BASED_DIR64 relocation type

IMAGE_REL_BASED_HIGH3ADJ relocation type

IMAGE_REL_BASED_HIGHADJ relocation type

IMAGE_REL_BASED_HIGHLOW relocation type

IMAGE_REL_BASED_HIGH relocation type

IMAGE_REL_BASED_IA64_IMM64 relocation type

IMAGE_REL_BASED_LOW relocation type

IMAGE_REL_BASED_MIPS_JMPADDR16 relocation type

IMAGE_REL_BASED_MIPS_JMPADDR relocation type

IMAGE_REL_BASED_REL32 relocation type

IMAGE_REL_BASED_SECTION relocation type

IMAGE_SECTION_HEADER structure

implementation

Implementation column

Implementation entry

Implementation flags

Implementation token

implements clause

implements leaf

ImplFlags binary flag entry

ImplFlags entry, Method table

<impl> nonterminal symbol

Import Address table (IAT)

Import Address table address

import flag

Import table address

import type implementation flags

IndexOutOfRange exception

indirect call signatures

indirect loading

initialization data

init keyword

initonly contract flag

initonly flag

initonly method

InlineIL tool

input/output flags

INSERT-FORWARDSLASH-HEREBYTES option

INSERT-FORWARDSLASH-HEREDEBUG option, ILAsm compiler

INSERT-FORWARDSLASH-HEREDLL command-line option

INSERT-FORWARDSLASH-HEREDLL option, ILAsm compiler

INSERT-FORWARDSLASH-HEREITEM=<item_description> option

INSERT-FORWARDSLASH-HEREITEM option

INSERT-FORWARDSLASH-HEREKEYINSERT-COLON-HERE<private_key_file_name> option, ILAsm compiler

INSERT-FORWARDSLASH-HEREKEYINSERT-COLON-HERE@<private_key_source_name> option, ILAsm compiler

INSERT-FORWARDSLASH-HERELINENUM option

INSERT-FORWARDSLASH-HEREMETAINFO[=<met_opt>] option

INSERT-FORWARDSLASH-HEREMETAINFO options

INSERT-FORWARDSLASH-HERENOBAR option

INSERT-FORWARDSLASH-HERENOIL option

INSERT-FORWARDSLASH-HEREOUTINSERT-COLON-HERE<file_name> option, ILAsm compiler

INSERT-FORWARDSLASH-HERERAWEH option

INSERT-FORWARDSLASH-HERERESINSERT-COLON-HERE<unmanaged_resource_file_name> option, ILAsm compiler

INSERT-FORWARDSLASH-HERETEXT option

INSERT-FORWARDSLASH-HERETOKENS option

INSERT-FORWARDSLASH-HEREUNICODE option

INSERT-FORWARDSLASH-HEREUTF8 option

INSERT-FORWARDSLASH-HEREVISIBILITY=<vis>[+<vis>*] option

INSERT-FORWARDSLASH-HEREVIS option

INSERT-QUOTE-HEREsynthesizedINSERT-QUOTE-HERE (implicit) sequence points

Install-time code generation

instance constructor

instance destructors

instance fields

instance finalizers

instance initialization

instance keyword

instance members of value types

instance methods

instance modifier

instance vararg calling convention

instructions, IL

addressing fields

arithmetical instructions

arithmetical operations

bitwise operations

block operations

constant loading

conversion operations

indirect loading

indirect storing

logical condition check instructions

overflow arithmetical operations

overflow conversion operations

shift operations

stack manipulation

calling methods

constrained virtual calls

direct calls

indirect calls

tail calls

classes and value types

box <token> instruction

castclass <token> instruction

cpobj <token> instruction

initobj <token> instruction

isinst <token> instruction

ldnull instruction

ldstr <token> instruction

ldtoken <token> instruction

mkrefany <token> instruction

newobj <token> instruction

refanytype <token> instruction

refanyval <token> instruction

rethrow instruction

sizeof <token> instruction

stobj <token> instruction

throw instruction

unbox.any <token> instruction

unbox <token> instruction

code verifiability

stack type conversions

verification rules

labels and flow control instructions

break instruction

comparative branching instructions

conditional branching instructions

EH block ending instructions

integer offsets

managed EH block exiting instructions

prefix instruction

ret instruction

switch instruction

unconditional branching instructions

local block allocation

local variable loading

local variable reference loading

local variable storing

long-parameter form

method argument address loading

method argument list

method argument loading

method argument storing

overview

prefix instructions

short-parameter form

Vector instructions

element address loading

element loading

element storing

vector creation

int8 data type

int16 data type

int16 foo field

int32 data type

int32 flag

int32 foo field

int32 Foo(int32) virtual method

int32[,] specification

int32[ ][ ] specification

int64 data type

int64 flag

integer reference number (ID)

interface flag

interface implementations

InterfaceImpl metadata table

InterfaceImpl records

interface(s)

interface keyword

Interface token

interface type semantics flag

Intermediate language (IL)

internalcall method

International Organization for Standardization (ISO)

Internet Information Services (IIS)

interop assembly

interoperability

Interoperation

basic step

classification

thunks and wrappers (see Thunks and wrappers)

int value type

InvalidCast exception

IProvideClassInfo2INSERT-COLON-HEREINSERT-COLON-HEREGetGUID() method

IProvideClassInfoINSERT-COLON-HEREINSERT-COLON-HEREGetClassInfo() method

Itanium-specific assemblies

IX interface

IY interface

images  J, K

Just-in-time (JIT) compiler

images  L

Labels and flow control instructions

break instruction

command-line option /OPT

comparative branching instructions

conditional branching instructions

EH block ending instructions

ILAsm notation

integer offsets

managed EH block exiting instructions

prefix instructions

ret instruction

switch instruction

unconditional branching instructions

Lame Linker

_LARGE_ADDRESS_AWARE flag

ldfld instruction

ldtoken instruction

_LINE_NUMS_STRIPPED flag

literal contract flag

_LNK_INFO flag

_LNK_NRELOC_OVFL flag

Load Configuration table address

loader, in search of assemblies

Locale column

locale localization

localization

_LOCAL_SYMS_STRIPPED flag

local variables

local variables signatures

lpstr native type

lptstr native type

lpwstr native type

images  M

Machine types

main assembly

MajorVersion column

MajorVersion field, IMAGE_EXPORT_DIRECTORY

managed arrays

Managed code

managed compiler

Managed exception handling

managed executable file, structure of

COFF header

common language runtime header

data constants

data sections

EntryPointToken field

Flags field

header structure

managed resources

overview

relocation section

resources

StrongNameSignature field

text section

thread local storage

unmanaged export table

unmanaged resources

v-table

VTableFixups field

file pointer

MS-DOS headerINSERT-FORWARDSLASH-HEREstub and PE signature

MS-DOS header/stub and PE signature

overview

PE header

data directory table

overview

relative virtual address (RVA)

section

section headers

virtual address (VA)

Managed executables

managed method, Code management

managed module

managed PE file

managed pointer

managed resource(s)

managed resource metadata and declaration

managed/unmanaged marshaling

managed vectors

mandatory methods

manifest

ManifestResource declarations

ManifestResource metadata table

mapped fields

mapping instance fields

mapping static fields

marshaling

marshal(<native_type>) reserved flags

MaxStack value

MDH suboption, <met_opt>

mdtFieldDef token type

mdtMethodDef type

Member Reference (MemberRef) metadata item

MemberRef metadata table

MemberRef record

MemberRef signatures

MemberRef table

MemberRef token

_MEM_DISCARDABLE flag

_MEM_EXECUTE flag

_MEM_NOT_CACHED flag

_MEM_NOT_PAGED flag

_MEM_READ flag

_MEM_SHARED flag

_MEM_WRITE flag

Metadata

class attributes

class descriptor

class metadata

ClassLayout metadata table

InterfaceImpl metadata table

NestedClass metadata table

TypeDef metadata table

TypeRef metadata table

definition

field metadata

defining Field

overview

referencing Field

heaps

Blop

GUID

length compression formula

strings

managed module

method-related

method flags

method implementation flags

method implementation metadata

method name

method parameters

Method table record entries

referencing methods

optimized/compressed

pointer table

storage header structure

storage signature structure

stream header structure

stream referencing

structure of

table column descriptor structure

table column type codes

table descriptor structure

table stream

unoptimized/uncompressed

validation

Metadata tables

metadata token

method(s)

class constructors

and beforefieldinit flag

module constructors

overview

explicit method overriding

global

instance constructors

instance finalizers

local variables

metadata

method flags

method implementation flags

method implementation metadata

method name

method parameters

Method table record entries

overview

referencing methods

method header attributes

method overloading

method overriding and accessibility

overloading

overview

static, instance, virtual methods

variable argument lists

method bodies

MethodBody method, MethodImpl table

MethodDecl method, MethodImpl table

method definition (MethodDef)

MethodDef token

method header

method implementation

MethodImpl table

method keyword

MethodList

MethodSemantics table

firing method

samemethod

semantic entry

method signatures

MethodSpec table

instantiation

Method

Method table

method token(s)

<met_opt> suboptions

Microsoft intermediate language (MSIL)

Microsoft Windows Portable Executable and Common Object File Format (PE/COFF)

MinorVersion column

MinorVersion field, IMAGE_EXPORT_DIRECTORY

& modifier

modopt modifier

modopt([mscorlib]System.Runtime.CompilerServices.IsConst) modifier

modopt([mscorlib]System.Runtime.CompilerServices.IsLong)int32 modifier

modopt token

modreq modifier

modreq token

module constructors

Module declarations

module entry point

module linking, through round-tripping

Module metadata item

Module metadata table and declaration

ModuleRef declarations

ModuleRef metadata table and declaration

ModuleRef token

Modules

modules and assemblies

application domains

application domains as logical units of execution

Assembly metadata table and declaration

AssemblyRef metadata table and declaration

definition

ExportedType metadata table and declaration

File metadata table and declaration

loader in search of assemblies

managed resource metadata and declaration

manifest

Module metadata table and declaration

ModuleRef metadata table and declaration

order of manifest declarations in ILAsm

overview

private and shared assemblies

single-module and multimodule assemblies

[mscorlib]System.ActivatorINSERT-COLON-HEREINSERT-COLON-HERECreateInstance method

[mscorlib]System.ArgIterator class library value type, .NET Framework

[mscorlib]System.Array abstract class

[mscorlib]System.AsyncCallback type

[mscorlib]System.Delegate type

[mscorlib]System.Diagnostics.DebuggableAttribute attribute

[mscorlib]System.Enum class

[mscorlib]System.GCINSERT-COLON-HEREINSERT-COLON-HERESuppressFinalize class library method, .NET Framework

[mscorlib]System.IAsyncResult interface

[mscorlib]System.IConvertible interface

[mscorlib]System.Int32 value type

[mscorlib]System.MulticastDelegate type

[mscorlib]System.Object class

[mscorlib]System.Object parent

[mscorlib]System prefix

[mscorlib]System.Text.StringBuilder class

[mscorlib]System.Threading.WaitHandle class

[mscorlib]System.TypeINSERT-COLON-HEREINSERT-COLON-HEREGetTypeFromProgID method

[mscorlib]System.TypeINSERT-COLON-HEREINSERT-COLON-HEREInvokeMember method

[mscorlib]System.ValueType class

MS-DOS headerINSERT-FORWARDSLASH-HEREstub

multidimensional arrays

MultiDword value type

multilanguage projects

ASMMETA

compiling in debug mode

creative round-tripping

IL disassembler

IL inlining in high-level languages

module linking through round-tripping

overview

principles of round-tripping

resolving circular dependencies

using class augmentation

multimodule assembly(ies)

Mvid column

MyNameSpace.EnclINSERT-FORWARDSLASH-HERENestd1 definition

MyNameSpace.EnclINSERT-FORWARDSLASH-HERENestd1INSERT-FORWARDSLASH-HERENestd2 definition

images  N

Name column

Name entry

MemberRef metadata table

Method parameter

Method table

Name field

IMAGE_EXPORT_DIRECTORY

IMAGE_SECTION_HEADER structure

Name Pointer table (NPT)

Namespace

Namespace entry

Name type

native method, Code type

Nestd1 class

Nestd2 class

nested assembly visibility flag

NestedClass metadata table

NestedClass type

nested famandassem visibility flag

nested family visibility flag

nested famorassem visibility flag

nested private visibility flag

nested public visibility flag

nested types

.NET-oriented compilers

_NET_RUN_FROM_SWAP flag

newobj instruction

newslot flag

newslot method, control flag

NGEN utility

_NO_DEFER_SPEC_EXC flag

[no ILAsm keyword] reserved flags

noinlining method

nonblittable

nonpublic member fields

nonrunnable executables (DLL files)

nonvirtual method

nop instruction

“normal” data section

not-a-number (NAN)

notserialized contract flag

nullref constant type

NumberOfFunctions field, IMAGE_EXPORT_DIRECTORY

NumberOfLinenumbers field, IMAGE_SECTION_HEADER structure

NumberOfNames field, IMAGE_EXPORT_DIRECTORY

NumberOfRelocations field, IMAGE_SECTION_HEADER structure

NumberOfSections field

<num_of_args> value

images  O

object(s)

object references

object type

Odd.or.Even class

OddOrEven sample application

.assembly OddOrEven { }

AssemblyRef declaration

calling unmanaged code

class declaration

ansi keyword

auto keyword

class amendment

explicit keyword

.namespace Odd.or { … }

pseudoflags

sequential keyword

System.Object

Type Definition

value types

data declaration

field declaration

accessibility flags

Field Definition

int32 keyword

public and static keywords

global items

mapped fields

method declaration

AskForNumber label

cil and managed keyword

.locals init (int32 Retval)

Member Reference

metadata string constants

MethodDef

sentinel

sscanf method

stloc Retval

vararg method

void keyword

.module OddOrEven.exe

Mscorlib.dll

value type as placeholder

Offline verification tool

command-line options

error codes and messagess

/ERROR option, IL assembler

IL verifier (ILVerifier)

metadata validator (MDValidator)

PEVerify tool

Offset column

OffSet entry, FieldLayout metadata table

OffsetToData characterize

operation code (opcode)

optil method, Code type

optimization

optional header

Ordinal table (OT)

OtherAssembly assembly

Overflow exception

overriding methods

explicit method overriding

method overriding and accessibility

images  P

PackingSize entry

parameter(s)

marshaling

method parameters

ParamList entry, Method table

Param metadata table

Param record

Parent entry

Parent entry, Constant metadata table

parent of type

PE header

data directory table

overview

PE signature

PEVerify utility

PhysicalAddress/VirtualSize field, IMAGE_SECTION_HEADER structure

pinned modifier

PINSERT-FORWARDSLASH-HEREInvoke implementation map

PINSERT-FORWARDSLASH-HEREInvoke interaction

PINSERT-FORWARDSLASH-HEREInvoke thunk

pinvokeimpl method, Implementation flags

Platform-agnostic assemblies

platform-independence department

Platform invocation

platform-specific assemblies

pointer arithmetic

PointerToLinenumbers field, IMAGE_SECTION_HEADER structure

PointerToRawData field, IMAGE_SECTION_HEADER structure

PointerToRelocations field, IMAGE_SECTION_HEADER structure

preservesig method

prime module

primitive data types

primitive types in common language runtime

data pointer types

function pointer types

modifiers

native types

overview

primitive data types

variant types

vectors and arrays

private accessibility flag

private assembly(ies)

private flag

private instance constructor(s)

private method, Accessibility flag

privatescope accessibility flag

privatescope method

privatescope method, Accessibility flag

private strict virtual method

private visibility flag

Processor Architecture

Properties

property declaration

<const_decl> method

<param_type> method

<semantics> method

property metadata

get_<property_name> method

private field

PropertyMap table

property table

set_<property_name> method

property signatures

Property table

accessor methods

flag values

Name entry

PropFlags

Type entry

Pseudocustom attributes

public accessibility flag

public flag

PublicKey column

public method, Accessibility flag

public visibility flag

images  Q

qsort function

images  R

RAW suboption, <met_opt>

real class declaration

Record indexes (RIDs)

redundant local variable slot

references, class

reference types

reference variant

Reflection methods

region

relocation section

.reloc, PE file

.reloc section

_RELOCS_STRIPPED flag

_REMOVABLE_RUN_FROM_SWAP flag

representing classes in signatures

reqsecobj method, Reserved flags

requested permissions

Reserved

Reserved field

Reserved flags

ResolutionScope entry

ResolutionScope indicator

resource(s)

resource data

resource data description

resource directory strings

resource directory tables

Resource table address

ret instruction

<return_type> value

RevisionNumber column

round-tripping

creative

module linking through

principles of

.rsrc, PE file

.rsrc section

rtspecialname flag

rtspecialname method, Reserved flags

rtspecialname reserved flags

runtime

runtime method, Code type

RVA entry

FieldRVA table

Method table

RVA value

images  S

satellite assembly

_SCALE_INDEX flag

SCH suboption, <met_opt>

.sdata, PE file

.sdata section

sealed definition

sealed type semantics flag

SectionAlignment field

section headers

Security attributes

declaration

declarative actions

Assert action

Demand action

Deny action

Inheritance Demand action

Link Demand action

Permit Only action

Request Minimum action

Request Optional action

Request Refuse action

declarative security

action codes

metadata table

in .NET v4.0

embedded security requirements

declarative security

imperative security

permissions (see Security permissions)

permission set blob encoding

security policies

Security permissions

access permissions

active directory

assertion

ControlAppDomain

ControlDomainPolicy

ControlEvidence

ControlPolicy

ControlPrincipal

ControlThread

Domain Name System (DNS)

EnvironmentPermission

execution

FileDialogPermission

FileIOPermission

Flags

Infrastructure property

IsolatedStorageFilePermission

ReflectionPermission

RegistryPermission

RemotingConfiguration

SerializationFormatter

Skipverification

UnmanagedCode

custom permissions

Caspol.exe utility

declarative security mechanism

egistryPermission

ISecurityEncodable interface

principles

identity permissions

assembly version

PublisherIdentityPermission

SiteIdentityPermission

StrongNameIdentityPermission

UrlIdentityPermission

ZoneIdentityPermission

instance constructors

.NET Framework class

permission sets

sentinel modifier (…)

separate resource file(s)

Sequence entry, Method parameter

sequence points, tracking

<sequence> sequence number

sequential layout flag

sequential type layout

serializable type implementation flags

shared assembly(ies)

signature(s)

calling conventions

field signatures

indirect call signatures

local variables signatures

MemberRef signatures

method and property signatures

overview

representing classes in

type specifications

Signature entry

MemberRef metadata table

Method table

signed integer values

single-dimensional arrays

single encoded type (SET)

single-module assemblies

single-quoted literal

Size characterize

.size directive

SizeOfRawData field, IMAGE_SECTION_HEADER structure

SizeOfZeroFill field

.size parameter

<sizes> parameter

<size_param_number> parameter

slash character (INSERT-FORWARDSLASH-HERE)

Software development kit [SDK])

SomeOtherAssembly assembly

specialname contract flag

specialname flag

specialname method, Implementation flags

specialname type semantics flag

StandAloneSig metadata table

StandAloneSig table

StandAloneSig token

StartAddressOfRawData field

startINSERT-FORWARDSLASH-HEREend parameters

static contract flag

static fields

static flag

static members

static method(s)

static method, Contract flag

strict flag

strict method, control flag

strict virtual method

StringBuilder class

string constant

string heap

string type

strong names

strong name signature

StrongNameSignature field

structured exception handling (SEH) mechanism

summary local variables signature

Switch instruction

synchronized method

System.AsyncCallback delegate instance

_SYSTEM flag

System.Int32 instance

System namespace

System.Object class

declarations

System.Resources.ResourceManager class

System.Runtime.CompilerServices.InternalsVisibleToAttribute attribute

System.Runtime.InteropServices.UnmanagedType enumerator

images  T

tbstr native type

text section

.text, PE file

.text section

this pointer

thread local storage (TLS)

Thunks and wrappers

character

ILAsm keywords

implementation map

map metadata

binary flags

COM callable wrappers

IJW thunks

implementation map

ImportName entry

ImportScop entry

MappingFlag

MemberForward entry

VC++-generated mixed-code

name digging

pinvokeimpl flag

P/invoke thunks

TimeDateStamp field, IMAGE_EXPORT_DIRECTORY

TLS directory structure

tls keyword

.tls, PE file

TLS table address

Token(s)

coded tokens

compilers

internal encoding

size

tags

types

types and referenced tables

user-defined strings

validity

token compression procedure

top bit

ToString() method

tracking, the sequence points

traditional unmanaged client

two-dimensional array

type, parent of

Type control

TypeDef flags

TypeDefId token

TypeDef metadata table

TypeDef record

TypeDef table

TypeDef token

typedref typed reference

Type entry, Constant metadata table

type initializer

type library

.typelist directive

TypeLoad exception

TypeNamespace token

TypeName token

TypeRef metadata table

TypeRef metadata token

TypeRef token

types, nested

type specifications

TypeSpec record

TypeSpec table

images  U

Unbound objects

unboxed values

unboxing

unicode string formatting flags

Unicode (UTF-16) format

union declaration

unmanagedexp method, Implementation flags

unmanaged export table

unmanaged method, Code management

unmanaged modules

unmanaged PE file

unmanaged pointers

unmanaged resources

Unresolved MemberRef ‘Format’ error message

UNR suboption, <met_opt>

unsigned integer

_UP_SYSTEM_ONLY flag

#US stream

images  V

VAL suboption, <met_opt>

Value entry, Constant metadata table

_value_ field private

value flag

value semantics pseudoflags

value types

boxed and unboxed values

derivation of

instance members of

overview

valuetype type

value type variable

vararg calling convention

vararg method

VARENUM enumeration

variable argument lists

variable declaration

variable-length argument list

variables, local

VC++ compiler

vector(s)

vector arrays

Vector instructions

Address method

element address loading

element loading

element storing

ldelem.* instruction

stelem.* instructions

ELEMENT_TYPE_ARRAY type

ELEMENT_TYPE_SZARRAY type

Get method

Set method

vector creation

.ver directive

version policies

VirtualAddress field

VirtualAddress field, IMAGE_SECTION_HEADER structure

virtual call instruction

virtual flag

virtual method(s)

Contract flag

overriding

table control flags

visibility, class

visibility filtering

Visual Basic for Applications (VBA)

volatile. instruction

v-table

v-table fixup(s)

VTableFixup descriptors

VTableFixups field

VTableFixup table

.vtentry directive

.vtfixup declarations

.vtfixup directive

images  W

Windows Foundation Classes (WFC)

WORD entry

Wtypes.h file

images  X, Y, Z

X64-specific assemblies

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.133.131.168