MSIL Tutorial

• Visual C++ / C++»
• .NET / C#»
• Visual Basic»
• Others

• Blog
• Forums
• Videos
• Submit an Article
• Newsletter

 

 

codeguru

.NET / C#

.NET

General

IL

Read More in IL »

 

Download Worklight Developer Edition 5.0 This plugin includes development tooling as well as a built-in application server.

Sponsored

• Post a comment
• Email Article
• Print Article
• Share Articles

 

MSIL Tutorial

Posted by Unknown Unknown on December 2nd, 2002

•  
  0.25
  0.50
  0.75
  1.00
  1.25
  1.50
  1.75
  2.00
  2.25
  2.50
  2.75
  3.00
  3.25
  3.50
  3.75
  4.00
  4.25
  4.50
  4.75
  5.00
• Vote!

• Tweet
•  
• inShare

Introduction

Microsoft Intermediate Language (MSIL) is a language used as the output of a number of compilers (C#, VB, .NET, and so forth). The ILDasm (Intermediate Language Disassembler) program that ships with the .NET Framework SDK (FrameworkSDK\Bin\ildasm.exe) allows the user to see MSIL code in human-readable format. By using this utility, we can open any .NET executable file (EXE or DLL) and see MSIL code.

The ILAsm program (Intermediate Language Assembler) generates an executable file from the MSIL language. We can find this program in the WINNT\Microsoft.NET\Framework\vn.nn.nn directory.

Any Visual C++ programmer starting with .NET development is interested in what happens in the low level of the .NET Framework. Learning MSIL gives a user the chance to understand some things that are hidden from a programmer working with C# or VB.NET. Knowing MSIL gives more power to a .NET programmer. We never need to write programs in MSIL directly, but in some difficult cases it is very useful to open the MSIL code in ILDasm and see how things are done.

A MSIL reference in DOC format is available to a .NET developer and may be found in the Framework SDK directory:

• FrameworkSDK\Tool Developers Guide\docs\Partition II Metadata.doc (Metadata Definition and Semantics). In this file, I found a description of all MSIL directives such as .entrypoint, .locals, and so on.
• FrameworkSDK\Tool Developers Guide\docs\Partition III CIL.doc (CIL Instruction Set) contains a full list of the MSIL commands.

I also used in my work in an ILDAsm tutorial from MSDN and an excellent article in the May 2001 issue of MSDN Magazine: "ILDASM is Your New Best Friend" by John Robbins.

I think the best way to learn the language is to write some programs in it. This is a reason I decided to make several small MSIL programs. Actually, I didn't write this code—the C# compiler generated it. I made some minor changes and added a lot of notes describing how MSIL is working.

Reading the sample projects attached to this article may help a .NET programmer understand Intermediate Language and easily read MSIL code when this is necessary.

General Information

All operations in MSIL are executed on the stack. When a function is called, its parameters and local variables are allocated on the stack. Function code starting from this stack state may push some values onto the stack, make operations with these values, and pop values from the stack.

Execution of both MSIL commands and functions is done in three steps:

1. Push command operands or function parameters onto the stack.
2. Execute the MSIL command or call function. The command or function pops their operands (parameters) from the stack and pushes onto the stack result (return value).
3. Read result from the stack.

Steps 1 and 3 are optional. For example, the void function doesn't push a return value to the stack.

The stack contains objects of value types and references to objects of reference type. Reference type objects are kept in the heap.

MSIL commands used to push values onto the stack are called ld... (load). Commands used to pop values from the stack are called st... (store), because values are stored in variables. Therefore, we will call the pushoperation loading and the pop operation storing.

Sample Projects

The code attached to this article contains a number of Console Applications written in MSIL. To build them, ensure that the ILAsm program is available through the PATH. Each project is done as a Visual Studio solution. The source IL file may be opened in the VS Text Editor. The build command runs the ILAsm program, which generates an exe file in the project directory. The run command executes this file. At the end of each program, I added these lines, which can be written in C#:

1. Console.WriteLine("Press Enter to continue");
2. Console::Read();

This is done to see the program output when it is run from Windows Explorer.

Here's a list of the included projects:

1. PrintString—prints the string to the console.
2. XequalN—assigns a value to the int variable and prints it to the console.
3. Operations—reads two numbers from the console; makes operations +, -, and *; and shows the result.
4. Array1—allocates int array, assign values to its elements; print elements and array length.
5. Compare—enters two numbers and prints the minimum.
6. Array2—fills array elements in loop and prints some elements.
7. Unsafe—uses unsafe pointers to access array elements.
8. PInvoke—calls Win32 API.
9. Classes—works with classes.
10. Exception—handles exceptions.

I suggest that you read these projects in the same order as they are described here. In the projects' descriptions given below, I explain each new MSIL command used in the program and show some code fragments.

PrintString Program

PrintString is the MSIL Hello, World application.

MSIL directives used in the code are as follows:

• .entrypoint—defines the application entry point (the function called by .NET Runtime when the program starts).
• .maxstack—defines the maximum stack depth used by the function code. The C# compiler sets always the exact value for each function. In the sample project, I set this value to 8.

MSIL commands are as follows:

• ldstr string—loads the string constant onto the stack.
• call function(parameters)—calls the static function. Parameters for the function should be loaded onto the stack before this call.
• pop—pops a value from the stack. Used when we don't need to store a value in the variable.
• ret—returns from a function.

Calling the static function is simple. We push to stack the function parameters, call the function, and read from the stack function return value (if function is not void). Console.WriteLine is an example of such a function.

Here is the code:

1. .assembly PrintString{}
2.  
3. /*
4. Console.WriteLine("Hello, World)"
5. */
6.  
7. .method staticpublicvoid main() il managed
8. {
9. .entrypoint // this function is the application
10. // entry point
11.  
12. .maxstack 8
13.  
14.  
15. // *****************************************************
16. // Console.WriteLine("Hello, World)";
17. // *****************************************************
18. ldstr "Hello, World"// load string onto stack
19.  
20. // Call static System.Console.Writeline function
21. // (function pops string from the stack)
22. call void[mscorlib]System.Console::WriteLine
23. (classSystem.String)
24.  
25.  
26. // *****************************************************
27. ldstr "Press Enter to continue"
28. call void[mscorlib]System.Console::WriteLine
29. (classSystem.String)
30.  
31.  
32. // Call the System.Console.Read function
33. call int32 [mscorlib]System.Console::Read()
34.  
35. // The pop instruction removes the top element from the stack.
36. // (remove number returned by Read() function)
37. pop
38. // *****************************************************
39.  
40. ret
41. }

XequalN Program

The program assigns a value to the integer variable and prints it to the console window.

Commands:

• ldc.i4.n—loads a 32-bit constant (n from 0 to 8) onto the stack
• stloc.n—stores a value from the stack to local variable number n (n from 0 to 3)

Code:

1. .assembly XequalN{}
2.  
3. // int x;
4. // x = 7;
5. // Console.WriteLine(x);
6.  
7. .method staticpublicvoid main() il managed
8. {
9. .entrypoint
10.  
11. .maxstack 8
12.  
13. .locals init ([0] int32 x)// Allocate local variable
15. // *****************************************************
16. // x = 7;
17. // *****************************************************
18. ldc.i4.7// load constant onto stack
19. stloc.0// store value from stack to
20. // var. 0
22. // *****************************************************
23. // Console.WriteLine(x);
24. // *****************************************************
25. ldloc.0// load var.0 onto stack
26. call void[mscorlib]System.Console::WriteLine(int32)
27.  
28. ret
29. }
30.  

Operations Program

The program reads two numbers from the console, makes simple math operations with them, and shows the result.

Commands:

• add—adds two values. Command parameters should be loaded onto the stack before the call. The function pops the parameters and pushes a result onto the stack.
• sub—subtracts two values.
• mul—multiplies two values.

Code fragments:

1. .assembly Operations{}
2. /*
3. // This program works as C# code:
5. int x, y, z;
6. string s;
8. Console.WriteLine("Enter x:");
9. s = Console.ReadLine();
10. x = Int32.Parse(s);
12. Console.WriteLine("Enter y:");
13. s = Console.ReadLine();
14. y = Int32.Parse(s);
16. z = x + y;
17. Console.Write("x + y = ");
18. Console.Write(z);
19. Console.WriteLine("");
21. z = x - y;
22. Console.Write("x - y = ");
23. Console.Write(z);
24. Console.WriteLine("");
26. z = x * y;
27. Console.Write("x * y = ");
28. Console.Write(z);
29. Console.WriteLine("");
30. */
31.  
32. .method staticpublicvoid main() il managed
33. {
34. .entrypoint
35. .maxstack 8
36.  
37. .locals init ([0] int32 x,
38. [1] int32 y,
39. [2] int32 z,
40. [3]string s)
41.  
42. // *****************************************************
43. // Console.WriteLine("Enter x:");
44. // *****************************************************
45. ldstr "Enter x:"// load string onto stack
46. call void[mscorlib]System.Console::WriteLine(string)
47.  
48. // *****************************************************
49. // s = Console.ReadLine();
50. // *****************************************************
51. call string[mscorlib]System.Console::ReadLine()
52. stloc.3// store value to var. 3
54. // *****************************************************
55. // x = Int32.Parse(s);
56. // *****************************************************
57. ldloc.3// load variable 3 onto stack
59. // Call System.Int32::Parse(string)
60. // Function pops string from stack and pushes to stack
61. // int32 value - result of parsing.
62. call int32 [mscorlib]System.Int32::Parse(string)
63.  
64. stloc.0// store value to var. 0
68. // *****************************************************
69. // Same operations with variable y
70. // *****************************************************
71. ldstr "Enter y:"
72. // load string
73. call void[mscorlib]System.Console::WriteLine(string)
74. // call
75. call string[mscorlib]System.Console::ReadLine()
76. // call
77. stloc.3
78. // store to var. 3
79. ldloc.3
80. // load var. 3
81. call int32 [mscorlib]System.Int32::Parse(string)
82. // call
83. stloc.1
84. // store to var. 1
85.  
86. // *****************************************************
87. // z = x + y;
88. // *****************************************************
89. ldloc.0// load variable 0 onto stack
90. ldloc.1// load variable 1 onto stack
91.  
92. // pop two values from the stack, add them and push result
93. // onto stack
94. add
95.  
96. stloc.2// store to variable 2
98. // *****************************************************
99. // Console.Write("x + y = ");
100. // *****************************************************
101. ldstr "x + y = "// load string onto stack
102. call void[mscorlib]System.Console::Write(string)
103.  
104. // *****************************************************
105. // Console.Write(z);
106. // *****************************************************
107. ldloc.2// load variable 2 onto stack
108. call void[mscorlib]System.Console::Write(int32)
109.  
110. // *****************************************************
111. // Console.WriteLine("");
112. // *****************************************************
113. ldstr ""// load string onto stack
114. call void[mscorlib]System.Console::WriteLine(string)
115.  
116. // Same operations with subtraction and multiplication ...
117.  
118. ret
119. }

Array1 Program

The program allocates the int array, assigns values to its elements, and then prints the elements and array length.

Commands:

• newarr type—creates an array of type elements. The array size should be loaded onto the stack before a call to this command. Loads onto the stack a reference to the array.
• stelem.i4—assigns a value to an array member. The value has type Int32. The array reference, index, and value should be loaded onto the stack before a call to this command.
• ldelema type—loads to the stack the address of an array element. The array reference and index should be loaded onto the stack before a call to this command. The address is used to call a non-static class function (see later).
• ldlen—loads the length of an array onto the stack. The array reference should be loaded onto the stack before a call to this command.
• ldloca.s variable—loads the address of the variable onto the stack.
• ldc.i4.s value—loads an Int32 constant onto the stack (used for values more than 8).
• conv.i4—converts value from the stack to Int32.
• call instance function(arguments)—calls a non-static class function. Before a call to a non-static function, we need to load onto the stack the address of the class object (used first as a hidden parameter, as in C++) and function arguments. In this sample object, the address is loaded using theldelema and ldloca commands.

In some code fragments in this sample, I wrote in the notes to stack the state starting after the last local variable. In this sample, we see the variable generated by the compiler. This variable is used to make the call to the non-static class function.

Code:

1. .assembly Array1{}
2.  
3. /*
4. // This program works as C# code:
6. int[] x = new int[5];
7. x[0] = 10;
8. x[1] = 20;
10. Console.WriteLine("x[0] = " + x[0].ToString());
11. Console.WriteLine("x[1] = " + x[1].ToString());
13. Console.WriteLine("Array length = " + x.Length.ToString());
15. */
16.  
17. .method staticpublicvoid main() il managed
18. {
19. .entrypoint
20. .maxstack 8
21.  
22. .locals init ([0] int32[] x,
23. [1] int32 tmp)// generated by compiler
26. // *****************************************************
27. // x = new int[5];
28. // *****************************************************
29. ldc.i4.5// load constant onto stack
30.  
31. // create array and store reference onto stack
32. newarr [mscorlib]System.Int32
33.  
34. // Store (pop) value from the stack and place it to local
35. // variable 0.
36. stloc.0
37.  
38. // *****************************************************
39. // x[0] = 10;
40. // *****************************************************
41. ldloc.0// Load local variable 0 onto stack (array)
42. ldc.i4.0// Load constant 0 to the stack (index)
43. ldc.i4.s 10// Load constant 10 to the stack (value)
44. stelem.i4 // array[index] = value
47. // The same operations with element number 1...
50. // ***************************************************
51. // Console.WriteLine("x[0] = " + x[0].ToString());
52. // ***************************************************
53. ldstr "x[0] = "// load string onto stack
54. // STACK: "x[0] = " (stack is shown from local
55. // variables)
56. ldloc.0// load variable 0 onto stack
57. ldc.i4.0// load constant 0 onto stack
58. // STACK: "x[0] = " -> x -> 0
59. // Load address of array element onto stack.
60. ldelema [mscorlib]System.Int32
61. // STACK: "x[0] = " -> pointer to Int32 instance
62. // 10
63. // Call non-static function System.Int32::ToString().
64. call instance string[mscorlib]System.Int32::ToString()
65. // STACK: "x[0] = " -> "10"
66. // call static System.String::Concat(string, string)
67. call string[mscorlib]System.String::Concat
68. (string,string)
69. // STACK: "x[0] = 10"
70. // call static System.Console::WriteLine(string)
71. call void[mscorlib]System.Console::WriteLine(string)
72. // STACK: empty
75. // The same operations with element number 1 ...
78. // *****************************************************
79. // Console.WriteLine("Array length = " + x.Length.ToString());
80. // *****************************************************
81. ldstr "Array length = "
82. // load string onto stack
83. // STACK: "Array length = "
84. ldloc.0
85. // load variable 0 to stack
86. // STACK: "Array length = " -> x
87. ldlen
88. // push the length of array onto stack
89. // STACK: "Array length = " -> 5
90. conv.i4
91. // Convert to int32, pushing int32 onto stack
92. // STACK: "Array length = " -> 5
93. stloc.1
94. // store to local variable 1 (tmp)
95. // STACK: "Array length = "
96. ldloca.s tmp
97. // load address of variable tmp onto stack
98. // STACK: "Array length = " -> &tmp
99. call instance string[mscorlib]System.Int32::ToString()
100. // STACK: "Array length = " -> "5"
101. call string[mscorlib]System.String::Concat
102. (string,string)
103. // STACK: "Array length = 5"
104. call void[mscorlib]System.Console::WriteLine(string)
105. // STACK: empty
106.  
107. ret
108. }

Compare Program

The program reads two numbers and prints their minimum.

Commands:

• bge.s label—goes to label if value1 is greater than or equal to value 2. Values 1 and 2 should be loaded onto the stack before a call to this command.
• br.s label—goes to label.
• box value type—converts a value type to an Object and loads the Object's reference onto the stack.

Boxing in this program is caused by the C# line: Console.WriteLine("{0:d}", z);
Writing this line in this way: Console.WriteLine(z.ToString());
doesn't cause boxing.

Code:

1. .assembly Compare{}
2. /*
3. int x, y, z;
4. string s;
6. Console.WriteLine("Enter x:");
7. s = Console.ReadLine();
8. x = Int32.Parse(s);
10. Console.WriteLine("Enter y:");
11. s = Console.ReadLine();
12. y = Int32.Parse(s);
14. if ( x < y )
15. z = x;
16. else
17. z = y;
19. Console.WriteLine("{0:d}", z);
20. */
21.  
22. .method staticpublicvoid main() il managed
23. {
24. .entrypoint
25. .maxstack 8
27. .locals init ([0] int32 x,
28. [1] int32 y,
29. [2] int32 z,
30. [3]string s)
31.  
32. // *****************************************************
33. // Console.WriteLine("Enter x:");
34. // *****************************************************
35. ldstr "Enter x:"// load string onto stack
36. call void[mscorlib]System.Console::WriteLine(string)
38. // *****************************************************
39. // s = Console.ReadLine();
40. // *****************************************************
41. call string[mscorlib]System.Console::ReadLine()
42. stloc.3// store to var. 3
44. // *****************************************************
45. // x = Int32.Parse(s);
46. // *****************************************************
47. ldloc.3// load var. 3 onto stack
48. call int32 [mscorlib]System.Int32::Parse(string)
49. stloc.0// store to var. 0
51. // The same operations for y ...
53. // *****************************************************
54. // branch
55. // if ( x >= y ) goto L_GR;
56. // *****************************************************
57. ldloc.0// load x onto stack (value 1)
58. ldloc.1// load y onto stack (value 2)
59. bge.s L_GR // goto L_GR if value1 is greater
60. // than or equal to value2
62. // *****************************************************
63. // z = x
64. // *****************************************************
65. ldloc.0// load variable 0 onto stack
66. stloc.2// store to variable 2
67.  
68. br.s L_CONTINUE // goto L_CONTINUE
69.  
70. L_GR:
71.  
72. // *****************************************************
73. // z = y
74. // *****************************************************
75. ldloc.1// load variable 1 onto stack
76. stloc.2// store to variable 2
77.  
78. L_CONTINUE:
79.  
80. // *****************************************************
81. // Console.WriteLine("{0:d}", z);
82. // NOTE: this line causes boxing.
83. // *****************************************************
84. ldstr "{0:d}"// load string onto stack
85. ldloc.2// load variable 2 to stack (z)
86. box [mscorlib]System.Int32// convert Int32 to Object
87. call void[mscorlib]System.Console::WriteLine(string,object)
88.  
89. ret
90. }

Array2 Program

The program fills an array in the loop and prints its elements. This time, we add the static functionShowNumber(int), which is called from main.

Commands:

• blt.s label—goes to label if value 1 is less than value 2. Values 1 and 2 should be loaded onto the stack before a call to this command.
• ldelem.i4—loads an array element onto the stack. A reference to the array and index should be loaded onto the stack before a call to this command.
• ldarga.s argument—loads the address of the function argument onto the stack.

We can see in this program that the for loop is implemented in MSIL using labels.

Code:

1. .assembly Array2{}
2. /*
4. int[] px = new int[100];
5. int i;
7. for ( i = 1; i < 100; i++ )
8. {
9. px[i] = i + 1;
10. }
12. ShowNumber(px[5]);
13. ShowNumber(px[10]);
16. static void ShowNumber(int n)
17. {
18. Console.WriteLine(n.ToString());
19. }
20. */
21.  
22. .method staticpublicvoid main() il managed
23. {
24. .entrypoint
25. .maxstack 8
26.  
27. .locals init ([0] int32[] px,
28. [1] int32 i)
29.  
30. // *****************************************************
31. // x = new int[100]
32. // *****************************************************
33. ldc.i4.s 100// load constant onto
34. // stack
35. newarr [mscorlib]System.Int32// allocate Int32
36. stloc.0// store to variable 0
38. // *****************************************************
39. // i = 1
40. // *****************************************************
41. ldc.i4.1// load constant onto stack
42. stloc.1// store to variable 1
43.  
44. br.s CHECK_COUNTER // goto CHECK_COUNTER
45.  
46. START_LOOP:
47. // *****************************************************
48. // px[i] = i + 1;
49. // *****************************************************
50. ldloc.0// load variable 0 to stack
51. // STACK: px
52. ldloc.1// load variable 1 to stack
53. // STACK; px -> i
54. ldloc.1// load variable 1 to stack
55. // STACK: px -> i -> i
56. ldc.i4.1// load constant to stack
57. // STACK: px -> i -> i -> 1.
58. add // add last two values
59. // STACK: px -> i -> i+1
60. // (array,index,value)
61. stelem.i4 // store value to array element:
62. // array[index] = value
63. // STACK: empty
64. // *****************************************************
65. // i = i + 1
66. // *****************************************************
67. ldloc.1// load variable 1 onto stack
68. ldc.i4.1// load constant onto stack
69. add // add
70. stloc.1// store to variable 1
71.  
72. CHECK_COUNTER:
73. // *****************************************************
74. // if i < 100 goto start f loop
75. // *****************************************************
76. ldloc.1// load variable 1 onto stack
77. ldc.i4.s 100// load constant onto stack
78. blt.s START_LOOP // if value1 < value2 go to
79. // START_LOOP
82. // *****************************************************
83. // ShowNumber(px[5]
84. // *****************************************************
85. ldloc.0// load variable 0 onto stack
86. // (array)
87. ldc.i4.5// load constant onto stack
88. // (index)
89. ldelem.i4 // load array element to stack
90. call voidShowNumber(int32)// call ShowNumber
92. // *****************************************************
93. // ShowNumber(px[10]
94. // *****************************************************
95. ldloc.0
96. ldc.i4.s 10
97. ldelem.i4
98. call voidShowNumber(int32)
99.  
100. ret
101. }
102.  
103. .method staticpublicvoidShowNumber(int32 n) il managed
104. {
105. .maxstack 1
107. ldarga.s n // load to stack address of argument n
109. call instance string[mscorlib]System.Int32::ToString()
110. call void[mscorlib]System.Console::WriteLine(string)
112. ret
113. }

Unsafe Program

The program fills and prints the int array using an unsafe pointer.

In this program, we see the new, unsafe types: int32* and int32&. The pinned keyword, used with a local variable, prevents GC from moving the object pointed to by the variable.

Commands:

• dup—duplicates the value on the stack.
• stind.i4—stores the value by address. The address and value should be loaded onto the stack before a call to this command.

Code:

1. .assembly Unsafe{}
2. /*
3. int[] nArray = new int[5];
4. int i;
5. int* pCurrent;
7. fixed ( int* pArray = nArray )
8. {
9. pCurrent = pArray;
11. for ( i = 0; i < 5; i++ )
12. {
13. *pCurrent++ = i + 1;
14. }
15. }
17. for ( i = 0; i < 5; i++ )
18. {
19. Console.WriteLine(nArray[i].ToString());
20. }
22. */
23.  
24. .method staticpublicvoid main() il managed
25. {
26. .entrypoint
27. .maxstack 8
28.  
29. .locals ([0] int32[] nArray,
30. [1] int32 i,
31. [2] int32* pCurrent,
32. [3] int32& pinned pArray)// GC doesn't move
33. // pointed object
35. // *****************************************************
36. // nArray = new int[5];
37. // *****************************************************
38. ldc.i4.5// load constant 5 onto
39. // stack
40. newarr [mscorlib]System.Int32// create array Int32[5]
41. stloc.0// store value from stack
42. // to local var. o
44. // *****************************************************
45. // pArray = nArray (pArray = &nArray[0])
46. // *****************************************************
47. ldloc.0
48. // load variable 0 onto stack (array)
49. ldc.i4.0
50. // load constant 0 onto stack (index)
51. ldelema [mscorlib]System.Int32
52. // load address of array[index] to stack
53. stloc.3
54. // store value from stack to local var. 3
56. // *****************************************************
57. // pCurrent = pArray;
58. // *****************************************************
59. ldloc.3// load variable 3 onto stack
60. conv.i // convert to native int
61. stloc.2// store to variable 2
63. // *****************************************************
64. // i = 0
65. // *****************************************************
66. ldc.i4.0// load constant 0 onto stack
67. stloc.1// store value to var. 1
69. // *****************************************************
70. // goto CHECK_COUNTER
71. // *****************************************************
72. br.s CHECK_COUNTER
73.  
74. START_LOOP:
75.  
76. // *****************************************************
77. // *pCurrent++ = i + 1 [STACK]
78. // *****************************************************
79. // 1) keep old pCurrent value on the stack and increment
80. // pCurrent
81. ldloc.2
82. // load variable 2 onto stack [pCurrent]
83. dup
84. // duplicate the top value of the stack
85. // [pCurrent pCurrent]
86. ldc.i4.4
87. // load constant 4 onto stack [pCurrent pCurrent 4]
88. add
89. // add [pCurrent pCurrent + 4]
90. stloc.2
91. // store from stack to variable 2 [pCurrent]
93. // 2) write (i+1) by old pCurrent value kept on the stack
94. ldloc.1
95. // load variable 1 onto stack [pCurrent i]
96. ldc.i4.1
97. // load constant 1 onto stack [pCurrent i 1]
98. add // add [pCurrent i+1]
99. // address value
100. stind.i4
101. // store value by address [empty]
103. // *****************************************************
104. // i = i + 1
105. // *****************************************************
106. ldloc.1// load variable 1 onto stack
107. ldc.i4.1// load constant 1 onto stack
108. add // add
109. stloc.1// store to variable 1
110.  
111. CHECK_COUNTER:
112.  
113. // *****************************************************
114. // if (i < 5) goto START_LOOP;
115. // *****************************************************
116. ldloc.1// load variable 1 onto stack
117. ldc.i4.5// load constant 5 onto stack
118. blt.s START_LOOP // goto if less
120. // *****************************************************
121. // pArray = 0 fixed block finished
122. // *****************************************************
123. ldc.i4.0// load constant 0 to stack
124. conv.u // convert to native unsigned int,
125. // pushing native int on stack
126. stloc.3// store in variable 3
128. // print array elements to console...
129.  
130. ret
131. }

PInvoke Program

The program shows the computer name using the Win32 API GetComputerName and MessageBox. API declarations in MSIL look like this:

1. .method public hidebysig static pinvokeimpl("kernel32.dll"
2. autochar winapi)
3. int32 GetComputerName(
4. class[mscorlib]System.Text.StringBuilder
5. marshal( lptstr) buffer,
6. int32& size) cil managed preservesig
7. {
8. }
9.  
10. .method public hidebysig static pinvokeimpl("User32.dll"
11. autochar winapi)
12. int32 MessageBox(nativeint hWnd,
13. string marshal( lptstr) lpText,
14. string marshal( lptstr) lpCaption,
15. int32 uType) cil managed preservesig
16. {
17. }

They are called by the same rules as other any functions.

Classes Program

In previous programs, we called the class functions from the static function main. In this program, we will see how to write classes. The program contains two classes: Class1, with function main; and SampleClass, created in main.

Directive:

• .field—defines class member. Used with keywords public, private, static, and so forth.

Commands:

• stsfld static field—replaces the value of the static field with the value from the the stack.
• ldfld field—loads a non-static class field onto the stack. The address of the class instance should be loaded onto the stack before a call to this command.
• ldarg.n—loads argument number n onto the stack. In a non-static class function, argument 0 is a hidden argument and points to the this instance.
• newobj constructor—creates a new instance of a class using constructor. Constructor parameters should be loaded onto the stack before this call. A reference to the created instance is loaded onto the stack.
• callvirt instance function—calls a late-bound method on an object.

Code:

1. .assembly Classes{}
2. /*
3. class SampleClass
4. {
5. private int m_n;
6. private string m_s;
8. public static int nStatic = 10;
10. public SampleClass(int n, string s)
11. {
12. m_n = n;
13. m_s = s;
14. }
16. public int Number
17. {
18. get
19. {
20. return m_n;
21. }
22. }
24. public string String
25. {
26. get
27. {
28. return m_s;
29. }
30. }
32. };
34. class Class1
35. {
36. [STAThread]
37. static void Main(string[] args)
38. {
39. SampleClass o = new SampleClass(1, "Sample");
41. Console.WriteLine(SampleClass.nStatic.ToString());
43. Console.WriteLine(o.Number.ToString());
45. Console.WriteLine(o.String);
46. }
47. }
48. */
49.  
50.  
51. .classprivateauto ansi beforefieldinit SampleClass
52. extends[mscorlib]System.Object
53. {
54. .field private int32 m_n // private int m_n;
55. .field privatestring m_s // private string m_s;
56. .field publicstatic int32 nStatic // public static int
57. // nStatic;
59. // private static constructor generated by compiler
60. // (generated to initialize static class member)
61. .method private hidebysig specialname rtspecialname static
62. void.cctor() cil managed
63. {
64. .maxstack 8
65.  
66. // *************************************************
67. // nStatic = 10
68. // *************************************************
69. ldc.i4.s 10// load constant onto stack
70. // The stsfld instruction replaces the value of a static
71. // field with a value from the stack
72. stsfld int32 SampleClass::nStatic
73.  
74. ret
75. }
76.  
77. // constructor
78. // public SampleClass(int n, string s)
79. //
80. .method public hidebysig specialname rtspecialname
81. instance void.ctor(int32 n,string s) cil managed
82. {
83. .maxstack 8
84.  
85. // *************************************************
86. // Call base class constructor
87. // *************************************************
88. ldarg.0// Load argument 0 onto stack (hidden
89. // pointer to this)
90. // call Object constructor
91. call instance void[mscorlib]System.Object::.ctor()
92.  
93. // *************************************************
94. // m_n = n
95. // *************************************************
96. ldarg.0// Load argument 0 onto stack
97. // (hidden pointer to this)
98. ldarg.1// load argument 1 onto stack (n)
99. // store value n in field m_n in instance pointed
100. // by this
101. stfld int32 SampleClass::m_n
102.  
103. // *************************************************
104. // m_s = s
105. // *************************************************
106. ldarg.0// Load argument 0 onto stack
107. // (hidden pointer to this)
108. ldarg.2// load argument 1 onto stack (s)
109. // store value s in field m_s in instance pointed
110. // by this
111. stfld stringSampleClass::m_s
112.  
113. ret
114. }
115.  
116. // Number property
117. .property instance int32 Number()
118. {
119. // call get_Number
120. .get instance int32 SampleClass::get_Number()
121. }
122.  
123. .method public hidebysig specialname instance int32
124. get_Number() cil managed
125. {
126. .maxstack 8
127.  
128. // variable generated by compiler
129. .locals ([0] int32 tmp)
130.  
131. // *************************************************
132. // return m_n;
133. // *************************************************
134. ldarg.0
135. // load argument 0 (this pointer)
136. ldfld int32 SampleClass::m_n
137. // load field of object pointed by stack value
138. stloc.0
139. // store in variable 0
140. ldloc.0
141. // load variable 0 onto stack (return value
142. // of function)
143.  
144. ret
145. }
146.  
147. // String property
148. .property instance stringString()
149. {
150. .get instance stringSampleClass::get_String()
151. }
153. .method public hidebysig specialname instance string
154. get_String() cil managed
155. {
156. .maxstack 8
157.  
158. // variable generated by compiler
159. .locals ([0]string tmp)
160.  
161. ldarg.0
162. // load argument 0 (this pointer)
163. ldfld stringSampleClass::m_s
164. // load field of object pointed by stack value
165. stloc.0
166. // store in variable 0
167. ldloc.0
168. // load variable 0 onto stack (return value
169. // of function)
170. ret
171. }
172. }
173.  
174.  
175. .classprivateauto ansi beforefieldinit Class1
176. extends[mscorlib]System.Object
177. {
178. // public default constructor
179. .method public hidebysig specialname rtspecialname
180. instance void.ctor() cil managed
181. {
182. .maxstack 8
183.  
184. // *************************************************
185. // Call base class constructor
186. // *************************************************
187. ldarg.0
188. // load this pointer
189. call instance void[mscorlib]System.Object::.ctor()
190. // call Object constructor
191.  
192. ret
193. }
194.  
195. // Main function
196. .method private hidebysig staticvoidMain(string[] args)
197. cil managed
198. {
199. // this method is the entry point to the application
200. .entrypoint
201.  
202. // Custom attribute
203. .custom instance void[mscorlib]System.
204. STAThreadAttribute::.ctor()=(01000000)
205.  
206. .maxstack 8
207.  
208. .locals ([0]classSampleClass o,
209. [1] int32 tmp)// generated by compiler
211. // *************************************************
212. // o = new SampleClass(1, "Sample");
213. // *************************************************
214. ldc.i4.1// load constant 1 onto
215. // stack
216. ldstr "Sample"// load string constant
217. // onto stack
218. // create new object SampleClass passing 2 parameters
219. // from stack.
220. // Load reference to created object onto stack
221. newobj instance voidSampleClass::.ctor(int32,string)
222. stloc.0// store to variable 0
224. // *************************************************
225. // Access static class member
226. // Console.WriteLine(SampleClass.nStatic.ToString());
227. // *************************************************
229. // Load the address of the static field on the stack
230. ldsflda int32 SampleClass::nStatic
231. // call Int32::ToString for object from stack
232. call instance string[mscorlib]System.Int32
233. ::ToString()
234. // call static WriteLine passing string from stack
235. // as parameter
236. call void[mscorlib]System.Console
237. ::WriteLine(string)
238.  
239. // *************************************************
240. // Call non-static class function
241. // Console.WriteLine(o.Number.ToString());
242. // *************************************************
243. ldloc.0// load variable 0
244. // call function for object from stack
245. call instance int32 SampleClass::get_Number()
246. stloc.1// store to variable 1
247. ldloca.s tmp // load address to stack
248. call instance string[mscorlib]System.Int32
249. ::ToString()
250. call void[mscorlib]System.Console
251. ::WriteLine(string)
252.  
253. // *************************************************
254. // Call non-static class member
255. // Console.WriteLine(o.String);
256. // *************************************************
257. ldloc.0
258. callvirt instance stringSampleClass::get_String()
259. call void[mscorlib]System.Console
260. ::WriteLine(string)
261.  
262. // *************************************************
263. ldstr "Press Enter to continue"
264. call void[mscorlib]System.Console
265. ::WriteLine(classSystem.String)
266. call int32 [mscorlib]System.Console::Read()
267. pop
268. // *************************************************
269.  
270. ret
271. }
272. }

Exception Program

The program divides two numbers, catching a divide-by-zero exception. The try/catch block in MSIL looks like it does in C#.

Command:

• leave.s label—leaves a protected block such as try or catch.

Code:

1. .assembly Exception{}
2.  
3. /*
4. int x, y, z;
5. string s;
7. Console.WriteLine("Enter x:");
8. s = Console.ReadLine();
9. x = Int32.Parse(s);
11. Console.WriteLine("Enter y:");
12. s = Console.ReadLine();
13. y = Int32.Parse(s);
15. try
16. {
17. z = x / y;
19. Console.WriteLine(z.ToString());
20. }
21. catch (Exception e)
22. {
23. Console.WriteLine(e.Message);
24. }
26. */
27.  
28. .method staticpublicvoid main() il managed
29. {
30. .entrypoint
31. .maxstack 8
32.  
33. .locals ([0] int32 x,
34. [1] int32 y,
35. [2] int32 z,
36. [3]string s,
37. [4]class[mscorlib]System.Exception e)
39. // Enter x, y ...
40.  
41. .try
42. {
43. // *************************************************
44. // z = x / y;
45. // *************************************************
46. ldloc.0// load var. 0
47. ldloc.1// load var. 1
48. div // divide
49. stloc.2// store in var. 2
51. // *************************************************
52. // Console.WriteLine(z.ToString());
53. // *************************************************
54. ldloca.s z // load address of z
55. call instance string[mscorlib]System.Int32
56. ::ToString()
57. call void[mscorlib]System.Console
58. ::WriteLine(string)
59.  
60. leave.s END_TRY_CATCH // exit try block
61. }
62. catch[mscorlib]System.Exception
63. {
64. stloc.s e // store exception thrown on
65. // the stack
67. // *************************************************
68. // Console.WriteLine(e.Message);
69. // *************************************************
70. ldloc.s e // load e
71. callvirt instance string[mscorlib]System.Exception
72. ::get_Message()
73. call void[mscorlib]System.Console
74. ::WriteLine(string)
75. leave.s END_TRY_CATCH // exit catch block
76. }
77.  
78. END_TRY_CATCH:
79.  
80. ret
81. }

Downloads

Download source - 43 Kb