Common Intermediate Language/Stack

Load

ldarg <uint16>

Load an argument at a given position and push it onto the stack.

.method int32 Add(int32, int32)
{
    ldarg 0 // 2
    ldarg 1 // 4
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldarg.s <uint8>

Load an argument at a given position and push it onto the stack. This takes up less space in bytecode compared to ldarg.

.method int32 Add(int32, int32)
{
    ldarg.s 0 // 2
    ldarg.s 1 // 4
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldarg.0 - ldarg.3

Load an argument at a given position and push it onto the stack.

.method int32 Add(int32, int32)
{
    ldarg.s.0 // 2
    ldarg.s.1 // 4
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldarga <uint16>

Load the address of an argument at a given position and push it onto the stack.

.method int32 Add(int32, int32)
{
    ldarga 0
    ldarga 1
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldarga.s <uint8>

Load the address of an argument at a given position and push it onto the stack. This takes up less space in bytecode compared to ldarga.

.method int32 Add(int32, int32)
{
    ldarga.s 0
    ldarga.s 1
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldc.i4 <int32>

Load a 32-bit (4-byte) integer and push it onto the stack.

.method int32 Add(int32, int32)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.i4 2
ldc.i4 4
call int32 Add(int32, int32)

ldc.i4.s <int8>

Load an 8-bit (1-byte) integer and push it onto the stack as 32-bit. This takes up less space in bytecode compared to ldc.i4.

.method int32 Add(int32, int32)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.i4.s 2
ldc.i4.s 4
call int32 Add(int32, int32)

ldc.i4.0 - ldc.i4.8

Load a 32-bit (4-byte) integer and push it onto the stack.

.method int32 Add(int32, int32)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.i4.2
ldc.i4.4
call int32 Add(int32, int32)

ldc.i4.m1 / ldc.i4.M1

Load -1 and push it onto the stack as 32-bit.

.method int32 Add(int32, int32)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.i4.m1
ldc.i4.M1
call int32 Add(int32, int32)

ldc.i8 <int64>

Load a 64-bit (8-byte) integer and push it onto the stack.

.method int64 Add(int64, int64)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.i8 2
ldc.i8 4
call int64 Add(int64, int64)

ldc.r4 <float32>

Load a 32-bit (4-byte) float and push it onto the stack.

.method float32 Add(float32, float32)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.r4 2.5
ldc.r4 4.5
call float32 Add(float32, float32)

ldc.r8 <float64>

Load a 64-bit (8-byte) float and push it onto the stack.

.method float64 Add(float64, float64)
{
    ldarg 0
    ldarg 1
    add
    ret
}

ldc.r8 2.5
ldc.r8 4.5
call float64 Add(float64, float64)

ldelem <type>

Load an element in an array and push it onto the stack.

// MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelem int32

ldelem <type>

Load an element in an array and push it onto the stack.

// MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelem int32

ldelem.i

Load an element in an array as a native int and push it onto the stack.

// MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelem.i

ldelem.i1

Load an element in an array as an int8 and push it onto the stack as an int32.

// (int32) MyClass.MyArray[5]
ldfld int8[] MyClass::MyArray
ldc.i4 5
ldelem.i1

ldelem.i2

Load an element in an array as an int16 and push it onto the stack as an int32.

// (int32) MyClass.MyArray[5]
ldfld int16[] MyClass::MyArray
ldc.i4 5
ldelem.i2

ldelem.i4

Load an element in an array as an int32 and push it onto the stack.

// MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelem.i4

ldelem.i8

Load an element in an array as an int64 and push it onto the stack.

// MyClass.MyArray[5]
ldfld int64[] MyClass::MyArray
ldc.i4 5
ldelem.i8

ldelem.r4

Load an element in an array as a float32 and push it onto the stack.

// MyClass.MyArray[5]
ldfld float32[] MyClass::MyArray
ldc.i4 5
ldelem.f4

ldelem.r8

Load an element in an array as a float64 and push it onto the stack.

// MyClass.MyArray[5]
ldfld float64[] MyClass::MyArray
ldc.i4 5
ldelem.f8

ldelem.ref

Load an element in an array and push it onto the stack as an object.

// (object) MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelem.ref

ldelem.u1

Load an element in an array as a uint8 and push it onto the stack as an int32.

// (int32) MyClass.MyArray[5]
ldfld unsigned int8[] MyClass::MyArray
ldc.i4 5
ldelem.u1

ldelem.u2

Load an element in an array as a uint16 and push it onto the stack as an int32.

// (int32) MyClass.MyArray[5]
ldfld unsigned int16[] MyClass::MyArray
ldc.i4 5
ldelem.u2

ldelem.u4

Load an element in an array as a uint32 and push it onto the stack as an int32.

// (int32) MyClass.MyArray[5]
ldfld unsigned int32[] MyClass::MyArray
ldc.i4 5
ldelem.u4

ldelem.u8

Load an element in an array as a uint64 and push it onto the stack as an int64.

// (int64) MyClass.MyArray[5]
ldfld unsigned int64[] MyClass::MyArray
ldc.i4 5
ldelem.u8

ldelema <type>

Load the address of an element as a <type> in an array and push it onto the stack.

// (managed pointer) MyClass.MyArray[5]
ldfld int32[] MyClass::MyArray
ldc.i4 5
ldelema int32

ldfld <type> <field>

Load a field's value, which is a <type>, and push it onto the stack.

ldfld int32 MyClass::MyField

ldflda <type> <field>

Load the address of a field, which is a <type>, and push it onto the stack.

ldflda int32 MyClass::MyField

ldflda <type> <field>

Load the address of a field, which is a <type>, and push it onto the stack.

ldflda int32 MyClass::MyField

ldftn <type> <method>

Load a pointer to a method, which returns <type>, referenced by <method> and push it onto the stack.

ldftn int32 MyClass::MyMethod()

ldind.i

Load a native int at an address and push it onto the stack.

ldarga 0
ldind.i

ldind.i1

Load an int8 at an address and push it onto the stack as an int32.

ldarga 0
ldind.i1

ldind.i2

Load an int16 at an address and push it onto the stack as an int32.

ldarga 0
ldind.i2

ldind.i4

Load an int32 at an address and push it onto the stack.

ldarga 0
ldind.i4

ldind.i8

Load an int64 at an address and push it onto the stack.

ldarga 0
ldind.i8

ldind.r4

Load an float32 at an address and push it onto the stack.

ldarga 0
ldind.r4

ldind.r8

Load an float64 at an address and push it onto the stack.

ldarga 0
ldind.r8

ldind.u1

Load an unsigned int8 at an address and push it onto the stack as an int32.

ldarga 0
ldind.u1

ldind.u2

Load an unsigned int16 at an address and push it onto the stack as an int32.

ldarga 0
ldind.u2

ldind.u4

Load an unsigned int32 at an address and push it onto the stack as an int32.

ldarga 0
ldind.u4

ldind.u8

Load an unsigned int64 at an address and push it onto the stack as an int64.

ldarga 0
ldind.u8

ldind.ref

Load an object at an address and push it onto the stack.

ldarga 0
ldind.ref

ldlen

Load the length of an array and push it onto the stack.

ldfld int32[] MyClass:MyArray
ldlen

ldloc <uint16>

Load the value of a local variable at a given position and push it onto the stack.

.method void Foo()
{
    .locals init (
        [0] int32 bar
    )

    ldc.i4.2
    stloc.0

    ldloc 0 // 2 (bar)
}

ldloc.s <uint8>

Load the value of a local variable at a given position and push it onto the stack. Takes up less space in bytecode compared to ldloc.

.method void Foo()
{
    .locals init (
        [0] int32 bar
    )

    ldc.i4.2
    stloc.0

    ldloc.s 0 // 2 (bar)
}

ldloc.0 - ldloc.3

Load the value of a local variable at a given position and push it onto the stack.

.method void Foo()
{
    .locals init (
        [0] int32 bar
    )

    ldc.i4.2
    stloc.0

    ldloc.0 // 2 (bar)
}

ldloca <uint16>

Load the address of a local variable and push it onto the stack.

.method void Foo()
{
    .locals init (
        [0] int32 bar
    )

    ldc.i4.2
    stloc.0

    ldloca 0 // bar
}

ldloca.s <uint8>

Load the address of a local variable and push it onto the stack. Takes up less space in bytecode compared to ldloca

.method void Foo()
{
    .locals init (
        [0] int32 bar
    )

    ldc.i4.2
    stloc.0

    ldloca.s 0 // bar
}

ldnull

Load null and push it onto the stack.

ldnull

...

brnull MyBranch

ldobj <type>

Pop an address off the stack, then push the value stored in that address.

ldflda int32 MyClass::MyInteger

...

ldobj int32

ldsfld <type> <field>

Load a static field's value, which is a <type>, and push it onto the stack.

ldsfld int32 MyClass::MyStaticField

ldsflda <type> <field>

Load the address of a static field, which is a <type>, and push it onto the stack.

ldsflda int32 MyClass::MyStaticField

ldstr <string>

Load a string and push it onto the stack.

ldstr "Hello, World!"

ldtoken <token>

Load a metadata token and push its runtime representation onto the stack.

ldtoken int32

ldvirtftn <type> <method>

Load the address of a virtual method, which returns <type>, and push it onto the stack.

ldvirtftn int32 MyClass::MyVirtualMethod()