MSIL Tutorial

Post by "KevinShan",  08-16-2007, 17:18
-----------------------------------------------------

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:

Push command operands or function parameters onto the stack.
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).
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 push operation 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:

PrintString—prints the string to the console.
XequalN—assigns a value to the int variable and prints it to the console.
Operations—reads two numbers from the console; makes operations +, -, and *; and shows the result.
Array1—allocates int array, assign values to its elements; print elements and array length.
Compare—enters two numbers and prints the minimum.
Array2—fills array elements in loop and prints some elements.
Unsafe—uses unsafe pointers to access array elements.
PInvoke—calls Win32 API.
Classes—works with classes.
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 static public void 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.                                  (class System.String)
    
24. 
    
25. 
    
26.     // *****************************************************
    
27.     ldstr "Press Enter to continue"
    
28.     call   void [mscorlib]System.Console::WriteLine
    
29.                                  (class System.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. 
   
2. .assembly XequalN {}
   
3. 
   
4. // int x;
   
5. // x = 7;
   
6. // Console.WriteLine(x);
   
7. 
   
8. .method static public void main() il managed
   
9. {
   
10.     .entrypoint
    
11. 
    
12.     .maxstack 8
    
13. 
    
14.     .locals init ([0] int32 x)  // Allocate local variable
    
15. 
    
16.     // *****************************************************
    
17.     // x = 7;
    
18.     // *****************************************************
    
19.     ldc.i4.7                    // load constant onto stack
    
20.     stloc.0                     // store value from stack to
    
21.                                 // var. 0
    
22. 
    
23.     // *****************************************************
    
24.     // Console.WriteLine(x);
    
25.     // *****************************************************
    
26.     ldloc.0                     // load var.0 onto stack
    
27.     call void [mscorlib]System.Console::WriteLine(int32)
    
28. 
    
29.     ret
    
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. 
   
2. .assembly Operations {}
   
3. /*
   
4. // This program works as C# code:
   
5. 
   
6.             int x, y, z;
   
7.             string s;
   
8. 
   
9.             Console.WriteLine("Enter x:");
   
10.             s = Console.ReadLine();
    
11.             x = Int32.Parse(s);
    
12. 
    
13.             Console.WriteLine("Enter y:");
    
14.             s = Console.ReadLine();
    
15.             y = Int32.Parse(s);
    
16. 
    
17.             z = x + y;
    
18.             Console.Write("x + y = ");
    
19.             Console.Write(z);
    
20.             Console.WriteLine("");
    
21. 
    
22.             z = x - y;
    
23.             Console.Write("x - y = ");
    
24.             Console.Write(z);
    
25.             Console.WriteLine("");
    
26. 
    
27.             z = x * y;
    
28.             Console.Write("x * y = ");
    
29.             Console.Write(z);
    
30.             Console.WriteLine("");
    
31. */
    
32. 
    
33. .method static public void main() il managed
    
34. {
    
35.     .entrypoint
    
36.     .maxstack 8
    
37. 
    
38.     .locals init ([0] int32 x,
    
39.            [1] int32 y,
    
40.            [2] int32 z,
    
41.            [3] string s)
    
42. 
    
43.     // *****************************************************
    
44.     // Console.WriteLine("Enter x:");
    
45.     // *****************************************************
    
46.     ldstr      "Enter x:"       // load string onto stack
    
47.     call       void [mscorlib]System.Console::WriteLine(string)
    
48. 
    
49.     // *****************************************************
    
50.     // s = Console.ReadLine();
    
51.     // *****************************************************
    
52.     call       string [mscorlib]System.Console::ReadLine()
    
53.     stloc.3                     // store value to var. 3
    
54. 
    
55.     // *****************************************************
    
56.     // x = Int32.Parse(s);
    
57.     // *****************************************************
    
58.     ldloc.3                     // load variable 3 onto stack
    
59. 
    
60.     // Call System.Int32::Parse(string)
    
61.     // Function pops string from stack and pushes to stack
    
62.     // int32 value - result of parsing.
    
63.     call       int32 [mscorlib]System.Int32::Parse(string)
    
64. 
    
65.     stloc.0                     // store value to var. 0
    
66. 
    
67. 
    
68. 
    
69.     // *****************************************************
    
70.     // Same operations with variable y
    
71.     // *****************************************************
    
72.     ldstr      "Enter y:"
    
73.                // load string
    
74.     call       void [mscorlib]System.Console::WriteLine(string)
    
75.                // call
    
76.     call       string [mscorlib]System.Console::ReadLine()
    
77.                // call
    
78.     stloc.3
    
79.                // store to var. 3
    
80.     ldloc.3
    
81.                // load var. 3
    
82.     call       int32 [mscorlib]System.Int32::Parse(string)
    
83.                // call
    
84.     stloc.1
    
85.                // store to var. 1
    
86. 
    
87.     // *****************************************************
    
88.     // z = x + y;
    
89.     // *****************************************************
    
90.     ldloc.0             // load variable 0 onto stack
    
91.     ldloc.1             // load variable 1 onto stack
    
92. 
    
93.     // pop two values from the stack, add them and push result
    
94.     // onto stack
    
95.     add
    
96. 
    
97.     stloc.2             // store to variable 2
    
98. 
    
99.     // *****************************************************
    
100.     // Console.Write("x + y = ");
     
101.     // *****************************************************
     
102.     ldstr      "x + y = "          // load string onto stack
     
103.     call       void [mscorlib]System.Console::Write(string)
     
104. 
     
105.     // *****************************************************
     
106.     // Console.Write(z);
     
107.     // *****************************************************
     
108.     ldloc.2                    // load variable 2 onto stack
     
109.     call       void [mscorlib]System.Console::Write(int32)
     
110. 
     
111.     // *****************************************************
     
112.     // Console.WriteLine("");
     
113.     // *****************************************************
     
114.     ldstr      ""                  // load string onto stack
     
115.     call       void [mscorlib]System.Console::WriteLine(string)
     
116. 
     
117.     // Same operations with subtraction and multiplication ...
     
118. 
     
119.     ret
     
120. }

复制代码

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

复制代码

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;
   
5. 
   
6.             Console.WriteLine("Enter x:");
   
7.             s = Console.ReadLine();
   
8.             x = Int32.Parse(s);
   
9. 
   
10.             Console.WriteLine("Enter y:");
    
11.             s = Console.ReadLine();
    
12.             y = Int32.Parse(s);
    
13. 
    
14.             if ( x < y )
    
15.                 z = x;
    
16.             else
    
17.                 z = y;
    
18. 
    
19.             Console.WriteLine("{0:d}", z);
    
20. */
    
21. 
    
22. .method static public void main() il managed
    
23. {
    
24.     .entrypoint
    
25.     .maxstack 8
    
26. 
    
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)
    
37. 
    
38.     // *****************************************************
    
39.     // s = Console.ReadLine();
    
40.     // *****************************************************
    
41.     call       string [mscorlib]System.Console::ReadLine()
    
42.     stloc.3                             // store to var. 3
    
43. 
    
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
    
50. 
    
51.     // The same operations for y ...
    
52. 
    
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
    
61. 
    
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 function ShowNumber(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. /*
   
3. 
   
4.             int[] px = new int[100];
   
5.             int i;
   
6. 
   
7.             for ( i = 1; i < 100; i++ )
   
8.             {
   
9.                 px = i + 1;
   
10.             }
    
11. 
    
12.             ShowNumber(px[5]);
    
13.             ShowNumber(px[10]);
    
14. 
    
15. 
    
16.         static void ShowNumber(int n)
    
17.         {
    
18.             Console.WriteLine(n.ToString());
    
19.         }
    
20. */
    
21. 
    
22. .method static public void 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
    
37. 
    
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 + 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
    
80. 
    
81. 
    
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       void ShowNumber(int32)   // call ShowNumber
    
91. 
    
92.     // *****************************************************
    
93.     // ShowNumber(px[10]
    
94.     // *****************************************************
    
95.     ldloc.0
    
96.     ldc.i4.s   10
    
97.     ldelem.i4
    
98.     call       void ShowNumber(int32)
    
99. 
    
100.     ret
     
101. }
     
102. 
     
103. .method static public void  ShowNumber(int32 n) il managed
     
104. {
     
105.   .maxstack  1
     
106. 
     
107.   ldarga.s   n          // load to stack address of argument n
     
108. 
     
109.   call       instance string [mscorlib]System.Int32::ToString()
     
110.   call       void [mscorlib]System.Console::WriteLine(string)
     
111. 
     
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&amp;. 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;
   
6. 
   
7. fixed ( int* pArray = nArray )
   
8. {
   
9.     pCurrent = pArray;
   
10. 
    
11.     for ( i = 0; i < 5; i++ )
    
12.     {
    
13.         *pCurrent++ = i + 1;
    
14.     }
    
15. }
    
16. 
    
17. for ( i = 0; i < 5; i++ )
    
18. {
    
19.     Console.WriteLine(nArray.ToString());
    
20. }
    
21. 
    
22. */
    
23. 
    
24. .method static public void 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&amp; pinned pArray)  // GC doesn't move
    
33.                                         // pointed object
    
34. 
    
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
    
43. 
    
44.     // *****************************************************
    
45.     // pArray = nArray    (pArray = &amp;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
    
55. 
    
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
    
62. 
    
63.     // *****************************************************
    
64.     // i = 0
    
65.     // *****************************************************
    
66.     ldc.i4.0                    // load constant 0 onto stack
    
67.     stloc.1                     // store value to var. 1
    
68. 
    
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]
    
92. 
    
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]
     
102. 
     
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
     
119. 
     
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
     
127. 
     
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&amp; size) cil managed preservesig
   
7. {
   
8. }
   
9. 
   
10. .method public hidebysig static pinvokeimpl("User32.dll"
    
11.                                              autochar winapi)
    
12.         int32  MessageBox(native int 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;
   
7. 
   
8.         public static int nStatic = 10;
   
9. 
   
10.         public SampleClass(int n, string s)
    
11.         {
    
12.             m_n = n;
    
13.             m_s = s;
    
14.         }
    
15. 
    
16.         public int Number
    
17.         {
    
18.             get
    
19.             {
    
20.                 return m_n;
    
21.             }
    
22.         }
    
23. 
    
24.         public string String
    
25.         {
    
26.             get
    
27.             {
    
28.                 return m_s;
    
29.             }
    
30.         }
    
31. 
    
32.     };
    
33. 
    
34.     class Class1
    
35.     {
    
36.         [STAThread]
    
37.         static void Main(string[] args)
    
38.         {
    
39.             SampleClass o = new SampleClass(1, "Sample");
    
40. 
    
41.             Console.WriteLine(SampleClass.nStatic.ToString());
    
42. 
    
43.             Console.WriteLine(o.Number.ToString());
    
44. 
    
45.             Console.WriteLine(o.String);
    
46.         }
    
47.     }
    
48. */
    
49. 
    
50. 
    
51. .class private auto ansi beforefieldinit SampleClass
    
52.        extends [mscorlib]System.Object
    
53. {
    
54.     .field private int32 m_n              // private int m_n;
    
55.     .field private string m_s             // private string m_s;
    
56.     .field public static int32 nStatic    // public static int
    
57.                                           // nStatic;
    
58. 
    
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      string SampleClass::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 string String()
     
149.     {
     
150.         .get instance string SampleClass::get_String()
     
151.     }
     
152. 
     
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      string SampleClass::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. .class private auto 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 static void  Main(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() = ( 01 00 00 00 )
     
205. 
     
206.         .maxstack  8
     
207. 
     
208.         .locals ([0] class SampleClass o,
     
209.                  [1] int32 tmp)          // generated by compiler
     
210. 
     
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 void SampleClass::.ctor(int32, string)
     
222.         stloc.0                         // store to variable 0
     
223. 
     
224.         // *************************************************
     
225.         // Access static class member
     
226.         // Console.WriteLine(SampleClass.nStatic.ToString());
     
227.         // *************************************************
     
228. 
     
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 string SampleClass::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(class System.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. 
   
2. .assembly Exception {}
   
3. 
   
4. /*
   
5.             int x, y, z;
   
6.             string s;
   
7. 
   
8.             Console.WriteLine("Enter x:");
   
9.             s = Console.ReadLine();
   
10.             x = Int32.Parse(s);
    
11. 
    
12.             Console.WriteLine("Enter y:");
    
13.             s = Console.ReadLine();
    
14.             y = Int32.Parse(s);
    
15. 
    
16.             try
    
17.             {
    
18.                 z = x / y;
    
19. 
    
20.                 Console.WriteLine(z.ToString());
    
21.             }
    
22.             catch (Exception e)
    
23.             {
    
24.                 Console.WriteLine(e.Message);
    
25.             }
    
26. 
    
27. */
    
28. 
    
29. .method static public void main() il managed
    
30. {
    
31.     .entrypoint
    
32.     .maxstack 8
    
33. 
    
34.     .locals ([0] int32 x,
    
35.              [1] int32 y,
    
36.              [2] int32 z,
    
37.              [3] string s,
    
38.              [4] class [mscorlib]System.Exception e)
    
39. 
    
40.     // Enter x, y ...
    
41. 
    
42.     .try
    
43.     {
    
44.         // *************************************************
    
45.         // z = x / y;
    
46.         // *************************************************
    
47.         ldloc.0                 // load var. 0
    
48.         ldloc.1                 // load var. 1
    
49.         div                     // divide
    
50.         stloc.2                 // store in var. 2
    
51. 
    
52.         // *************************************************
    
53.         // Console.WriteLine(z.ToString());
    
54.         // *************************************************
    
55.         ldloca.s   z            // load address of z
    
56.         call       instance string [mscorlib]System.Int32
    
57.                                    ::ToString()
    
58.         call       void [mscorlib]System.Console
    
59.                                    ::WriteLine(string)
    
60. 
    
61.         leave.s    END_TRY_CATCH        // exit try block
    
62.     }
    
63.     catch [mscorlib]System.Exception
    
64.     {
    
65.         stloc.s    e        // store exception thrown on
    
66.                             // the stack
    
67. 
    
68.         // *************************************************
    
69.         // Console.WriteLine(e.Message);
    
70.         // *************************************************
    
71.         ldloc.s    e                // load e
    
72.         callvirt   instance string [mscorlib]System.Exception
    
73.                                    ::get_Message()
    
74.         call       void [mscorlib]System.Console
    
75.                                    ::WriteLine(string)
    
76.         leave.s    END_TRY_CATCH        // exit catch block
    
77.     }
    
78. 
    
79.     END_TRY_CATCH:
    
80. 
    
81.     ret
    
82. }

复制代码

Downloads