In this series we examine the relationship and implementations of C++ and raw assembly code. In this post we create our own add function in gcc extended assembly.
In the previous post we wrote a short C++ program that loaded two numbers. Despite its simplicity in C++, we saw how the assembly version was comprised of several dozen individual instructions in a rather cryptic format. Much of this complexity stems from the fact that in our sample program we called a function to perform our addition. Calling functions means dealing with a stack, base pointers, and the setup and maintenance of that stack. It means dealing with memory offsets, relative positions, and several other factors. The good news is that at this point we can safely ignore these details. In fact, we will do well to ignore them and focus on just the core competencies of function implementation code. In other words, we’ll let gcc create the function shells, calls, and stack management, we’ll focus on the core logic.
The general idea is that we want to write assembly that adds two numbers together. There is a direct assembly instruction for doing so, add, and in this post we’ll implement it.
One of the key things to remember about writing assembly is that we’re dealing with very few abstractions. In C++:
-
int t = 10;
Has a very specific meaning, but its true meaning to the machine it runs on is hidden. It’s only after gcc compiles the code that int, t, and 10 mean anything to the processor. In assembly we free ourselves from these abstractions and deal with the very direct process of moving bits around.
Thus, our first step in writing assembly to add two numbers is to realize that the add instruction we’ll be using expects two parameters, neither of which can be memory locations. They can however, be registers. Thus, our first steps in code must be to load two registers with the values we want to add.
To load a value into a register we use the mov instruction, which for us in AT&T syntax takes the form of:
-
mov $0×2, %%rax;
This moves the immediate value (2) into the %rax register. Please keep in mind %rax is a 64-bit register, it would be %eax on 32-bit systems.
We then push our second number:
-
mov $0×1, %%rcx;
And finally, call the add instruction, passing in our two registers:
-
add %%rcx, %%rax;
The whole function in extended assembly looks like:
-
__asm__(
-
"mov $0×2, %%rax; \n\t"
-
"mov $0×1, %%rcx; \n\t"
-
"add %%rcx, %%rax; \n\t"
-
:
-
:
-
:"rax", "rcx");
Should we run this in our IDE, we would watch the rax and rcx register’s end up with 0×1 and 0×3, respectively.
Thing is, this is not a very useful construct, as immediate values means we’ve hard coded the return in by default. It’s much more realistic to accept parameters.
To do so, we take advantage of gcc extended syntax like so:
-
int rax = 2;
-
int rcx = 1;
-
-
cout << "(rax) before: " << rax << endl;
-
-
__asm__(
-
"mov %1, %%rax; \n\t"
-
"mov %2, %%rcx; \n\t"
-
"add %%rcx, %0; \n\t"
-
: "=m" (rax)
-
: "m" (rax), "m" (rcx)
-
:"rax", "rcx");
-
-
cout << "(rax) after: " << rax << endl;
Will output:
-
(rax) before: 2
-
(rax) after: 3
-
Press [Enter] to close the terminal …
While we now have plenty of control over implementation, it’s still a bit heavy on syntax. Thus, we can further optimize by letting gcc have full control over register assignment:
-
int rax = 2;
-
int rcx = 1;
-
-
cout << "(rax) before: " << rax << endl;
-
-
__asm__(
-
"add %2, %0; \n\t"
-
: "=r" (rax)
-
: "r" (rax), "r" (rcx)
-
:);
-
-
cout << "(rax) after: " << rax << endl;
Here we let gcc decide which registers to use, which leads to slightly faster code generation, but we may lose the exacting control we need.
At this point we now have a functioning addition routine. Of course we already know it’s not the most efficient, as we could/should be using lea. This is because while our actual hand-written assembly is shorter, we still need to place values in registers and use the two-step addition instruction.