The Microsoft compiler employs a few patterns in its code generation that you may want to become familiar with. <\/p>\n
As we saw earlier, a call to a If the method is virtual, then there is a vtable lookup: <\/p>\n If the method uses The Microsoft compiler uses a jump table for dense Consider the following fragment: <\/p>\n The resulting code may look like this:<\/p>\n Adding a level of indirection allows the level-2 jump table to be smaller. The trade-off is that you have to pay for a level-1 jump table, but if there are a lot of duplicates (such as those created by all the missing cases that go to If you stare at the output and do some reverse-compiling, you can imagine that the compiler internally rewrote it as <\/p>\n__thiscall<\/code> function passes the this<\/code> pointer in the ecx<\/var> register, with the remaining parameters passed on the stack. A typical calling sequence would go something like this: <\/p>\n\n; p->Foo(x, 42);\n\n push 42 ; parameter 2\n push dword ptr [ebp-24h] ; parameter 1\n mov ecx, dword ptr [ebp-20h] ; \"this\" for call\n call CThing::Foo ; call the function directly\n<\/pre>\n
\n; p->Foo(x, 42);\n\n push 42 ; parameter 2\n push dword ptr [ebp-24h] ; parameter 1\n mov ecx, dword ptr [ebp-20h] ; \"this\" for call\n mov eax, dword ptr [ecx] ; fetch vtable\n call dword ptr [eax+10h] ; call through the vtable\n<\/pre>\n
__stdcall<\/code> instead of __thiscall<\/code> (typically because it is a COM method), then the this<\/var> parameter is passed on the stack rather than in the ecx<\/var> register. <\/p>\n\n; p->Foo(x, 42);\n\n; non-virtual call\n push 42 ; parameter 2\n push dword ptr [ebp-24h] ; parameter 1\n push dword ptr [ebp-20h] ; \"this\" for call\n call CThing::Foo ; call the function directly\n\n; virtual call\n push 42 ; parameter 2\n push dword ptr [ebp-24h] ; parameter 1\n mov ecx, dword ptr [ebp-20h] ; \"this\" for call\n push ecx ; pass as stack parameter\n mov eax, dword ptr [ecx] ; fetch vtable\n call dword ptr [eax+10h] ; call through the vtable\n<\/pre>\n
switch<\/code> statements, but it adds a level of indirection so that multiple cases that leads to the same target share the same jump entry. <\/p>\n\n switch (value)\n {\n case 2:\n case 3:\n case 5:\n case 7:\n printf(\"prime\");\n break;\n\n case 4:\n case 9:\n printf(\"perfect square\");\n break;\n\n default:\n printf(\"I'm sure you're special\");\n break;\n }\n<\/pre>\n\n mov eax, dword ptr [ebp-30h] ; load value\n sub eax, 2 ; table starts with \"case 2\"\n cmp eax, 8 ; table has 8 entries\n jae case_default ; not in table, go to default case\n movzx eax, byte ptr [eax+level1] ; get the index into the second table\n jmp dword ptr [eax+level2] ; jump to handler\n\n ...\n\nlevel2 dd offset case_prime ; slot 0 is for cases 2, 3, 5, and 7\n dd offset case_square ; slot 1 is for cases 4 and 9\n dd offset case_default ; slot 2 is for everybody else\nlevel1 db 0, 0, 1, 0, 2, 0, 2, 1 ; generate the slots\n; 2 3 4 5 6 7 8 9 ; corresponding cases\n<\/pre>\n
default:<\/code>), the trade-off may be worth it. <\/p>\n\n enum SwitchResult { Prime, PerfectSquare, Default };\n static const unsigned char level1[] =\n { Prime, Prime, PerfectSquare, Prime,\n Default, Prime, Default, PerfectSquare };\n unsigned int index1 = (unsigned)value - 2;\n switch (index1 < 8 ? level1[index1] : Default)\n {\n case Prime:\n printf(\"prime\");\n break;\n\n case PerfectSquare:\n printf(\"perfect square\");\n break;\n\n case Default:\n printf(\"I'm sure you're special\");\n break;\n\n default:\n __assume(0); \/\/ not reached\n }\n<\/pre>\n