home comics writing pictures archive about

2017-01-07 - In IL: Grade Analyser (switch)

Last time we looked at the IL switch instruction. Today we are going to look at the switch statement in C# and see how it uses the IL switch instruction.

We are going to use a program that tests a student's grade and prints out a message.

Program.cs
using System;
namespace csSwitch
{
class Program
{
static void Main(string[] args)
{
char grade = 'B';
bool needToImprove = false;
switch (grade)
{
case 'A':
Console.WriteLine("Your grade is excellent");
needToImprove = false;
break;
case 'B':
Console.WriteLine("Your grade is good");
needToImprove = false;
break;
case 'C':
Console.WriteLine("Your grade is OK");
needToImprove = true;
break;
case 'D':
Console.WriteLine("Your grade is acceptable");
needToImprove = true;
break;
default:
Console.WriteLine("You failed");
needToImprove = true;
break;
}
if (needToImprove)
{
Console.WriteLine("You can do better");
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

Now if we compile the above program we get.

Main
.method private hidebysig static void Main(string[] args) cil managed
{
.entrypoint
// Code size 114 (0x72)
.maxstack 2
.locals init ([0] char grade,
[1] bool needToImprove)
IL_0000: ldc.i4.s 66
IL_0002: stloc.0
IL_0003: ldc.i4.0
IL_0004: stloc.1
IL_0005: ldloc.0
IL_0006: ldc.i4.s 65
IL_0008: sub
IL_0009: switch (
IL_0020,
IL_002e,
IL_003c,
IL_004a)
IL_001e: br.s IL_0058
IL_0020: ldstr "Your grade is excellent"
IL_0025: call void [mscorlib]System.Console::WriteLine(string)
IL_002a: ldc.i4.0
IL_002b: stloc.1
IL_002c: br.s IL_0064
IL_002e: ldstr "Your grade is good"
IL_0033: call void [mscorlib]System.Console::WriteLine(string)
IL_0038: ldc.i4.0
IL_0039: stloc.1
IL_003a: br.s IL_0064
IL_003c: ldstr "Your grade is OK"
IL_0041: call void [mscorlib]System.Console::WriteLine(string)
IL_0046: ldc.i4.1
IL_0047: stloc.1
IL_0048: br.s IL_0064
IL_004a: ldstr "Your grade is acceptable"
IL_004f: call void [mscorlib]System.Console::WriteLine(string)
IL_0054: ldc.i4.1
IL_0055: stloc.1
IL_0056: br.s IL_0064
IL_0058: ldstr "You failed"
IL_005d: call void [mscorlib]System.Console::WriteLine(string)
IL_0062: ldc.i4.1
IL_0063: stloc.1
IL_0064: ldloc.1
IL_0065: brfalse.s IL_0071
IL_0067: ldstr "You can do better"
IL_006c: call void [mscorlib]System.Console::WriteLine(string)
IL_0071: ret
} // end of method Program::Main
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

Looking at the IL we can clearly see the code writing text to the console, setting the needToImprove variable, and then doing some branching for each of the cases. This is all stuff we've seen before but what's going on before that?

The program starts by loading the value 66 into the grade variable. 66 is the Unicode value for the capital B letter. We then set the needToImprove variable to 0 which represents false. Then we push the grade variable onto the stack and subtract 65 from it. Why does it do that?

65 is the Unicode value for A. Since Unicode letters are in alphabetical order subtracting 65 from the grade variable converts the character value into an offset from A. So A becomes 0, B becomes 1, C becomes 2 and so on. As you will recall from last time switch instructions are 0 based so having the first option be 0 and subsequent options incrementing from there simplifies the switch instruction. Otherwise we would need to specify branching targets for 0 to 64 that all point to the default case.

So now let's look at the switch instruction. The following table shows the switch instruction branch index, the branch target, and the corresponding case statement.

Index Branch Target Case
0 ('A' - 65) IL_0020 case 'A'
1 ('B' - 65) IL_002e case 'B'
2 ('C' - 65) IL_003c case 'C'
3 ('D' - 65) IL_004a case 'D'

If you look at the instructions at each of the branch targets you can see they line up with the case statements perfectly.

There's only one thing left, the default case. Recall that if the value on the stack doesn't correspond to a target of the switch instruction then nothing happens and executions continues at the next instruction. Thus if the grade value isn't A, B, C, or D, execution will move on to the unconditional branch to IL_0058. This is our default case.

Next time we will try and bust the switch statement.

2016-12-17 - Programs aren't Permanent

After a certain age people begin to understand that objects still exist when you put them away. If you put a hammer on a shelf today it will likely still be there in a week and still be the same hammer. Programs on the other hand don't keep when you stop using them, at least not in the same way.

This is because programs don't contain components the way we would normally think of them. A hammer is made up of pieces of metal and plastic. The hammer is a hammer because of the specific shape of those pieces and how they are put together. A program isn't made up of stuff, it is made up of instructions.

When a program is launched it starts executing the instructions stored within it. These instructions generally start by building up data structures in memory that store a program's state. When a program is closed those data structures are destroyed. The information stored within them may be persisted into another form but the exact data structures the program was using to run no longer exist.

Imagine having to rebuild the hammer every time you needed to use it. The hammer would change each time based on the current circumstances. Maybe there wasn't a lot of free plastic one time so you ended up with a very short hammer, or there was an issue getting the metal so you ended up with just a handle.

Because a program is just instructions it is very dependant on the results of those instructions. If the results can change from one run to another then the program's behaviour can change. Some times it launches fine and other time it crashes immediately. It's all up to the circumstances in which the program is being launched.

This is why restarting a program can make it run better.

2016-11-26 - Parts of Speech: Introduction

I enjoy learning. I enjoy gaining a better understanding of how things work. Right now a lot of my time is spent learning about programming languages because they are important to my career and my hobbies, but I want to branch out into learning about language in general.

With this series I hope to learn more about the parts of speech. The different classifications of words, forms of words, usage of words. My hope is that this will improve my writing and may also help me learn another language.

Next time we will start off by learning about nouns.

2016-11-06 - In IL: Switch instruction

Along with the branching instructions that we have already seen there's a special multi-branching instruction. It is used in situations where there are multiple possible outcomes based the value of a single input.

switch

Instruction Binary Format
switch 0x45 <uint32> <int32> ... <int32>

The switch instruction is unique because its encoding is variable length. The encoded instruction contains a value, the uint32, that indicates the number of subsequent int32 values. These int32 values are the targets of the instruction and are the same as the int32 values that showed up when we looked at branching instructions. In IL assembly the uint32 would be computed based on the number of arguments, usually labels, to the switch instruction.

The switch instruction works by popping a value off of the stack and then using that value as an index into the instruction's target list. The instruction then jumps to the instruction indicated by the target at that index. If the value is 0 then the instruction jumps to the instruction indicated by the first target. If the value is 1 then the instruction jumps to the instruction indicated by the second target. If the value is greater than the number of targets then the instruction does nothing and execution moves on to the next instruction.

Next time we will look at some uses of the switch instruction.

Prev page

12 13 14 15 16

Prev page