Basic Inline Assembly
The format for inline assembly in C is very simple
asm ("statements");
__asm__("statements") can also be used
Whatever is inside the asm call will be placed as is in the assembly output generated by the C compiler. This assembly output is then fed to the assembler. This kind of inline assembly is good for doing things which can not be directly done using C, but we cant place these instructions modifying registers in the middle of the C code. Because compiler will just place this code in the assembly output and it will generate the assembly for the C code without knowing that you are messing up with the registers.
But if you write the content of a complete function using this statement it will work fine because you wont be messing up with the compiler generated asm code.
Lets see an example. Consider the following small program which calculates average of numbers in two arrays and stores the result in the third array.
int numX[5] = {10,20,30,40,50}; int numY[5] = {20,30,40,50,60}; int res[5]; void avg() { int i; for(i = 0; i < 5; ++i) { res[i] = (numX[i] + numY[i])/2; } } main() { int i; avg(); for(i =0; i <5 ; ++i) { printf("result[%d] = %d \n", i,res[i]); } }
Now we lets see how we can convert the division by two to asm using basic inline assembly.
void avg() { int i; for(i = 0; i < 5; ++i) { res[i] = (numX[i] + numY[i]); asm(" movl -4(%ebp), %eax ; move i to eax movl _res(,%eax,4), %ebx ; move res[i] to ebx sarl %ebx ; divide ebx by two by shifting right movl %ebx, _res(,%ebx,4) ; move ebx to res[i] "); } }
When we compile this program and run it, it works fine and prints result same as the previous program. Here we are lucky that we are changing the value of register eax and ebx and compiler is not using them to store some variable across the loop.
Following is the asm for the avg function in the above case. Notice that the compiler puts the asm statements inside the asm() function as it is inside two directives /APP and /NO_APP
Collapse_avg:
pushl %ebp
movl %esp, %ebp
subl $4, %esp
movl $0, -4(%ebp) # i
L2:
cmpl $4, -4(%ebp) # i
jle L5
jmp L1
L5:
movl -4(%ebp), %ecx # i
movl -4(%ebp), %edx # i
movl -4(%ebp), %eax # i
movl _numY(,%eax,4), %eax # numY
addl _numX(,%edx,4), %eax # numX
movl %eax, _res(,%ecx,4) # res
/APP
movl -4(%ebp), %eax
movl _res(,%eax,4), %ebx
sarl %ebx
movl %ebx, _res(,%eax,4)
/NO_APP
leal -4(%ebp), %eax
incl (%eax) # i
jmp L2
L1:
leave
ret
Here we can see that ebx is not at all used while eax is loaded with the value of i each time in the loop. so our asm code doesnt interfere with the compiler generated code. Now lets try to compile the same program with -O2 optimizations. Following is the asm code generated.
_avg:
pushl %ebp
xorl %edx, %edx
movl %esp, %ebp
movl $_numY, %ecx
pushl %esi
movl $_res, %esi
pushl %ebx
movl $_numX, %ebx
L6:
movl (%ecx,%edx,4), %eax # numY
addl (%ebx,%edx,4), %eax # numX
movl %eax, (%esi,%edx,4) # res
/APP
movl -4(%ebp), %eax
movl _res(,%eax,4), %ebx
sarl %ebx
movl %ebx, _res(,%eax,4)
/NO_APP
incl %edx # i
cmpl $4, %edx # i
jle L6
popl %ebx
popl %esi
popl %ebp
ret
Here compiler has tried to optimize the code by moving many things out of the loop and keeping the values of variables into the registers. This program wont work and will give core dump. The reason is that compiler is using ebx register to keep the pointer to numX and we are changing the value of ebx in our inline asm code. Compiler unaware of what we have done to ebx still assumes that ebx will have the pointer to numX.
In gcc you can use extended asm for telling the compiler what you did in your inline asm code. Like what registers you made dirty. You can even ask compiler to put the value of some variables into some resgisters for you.
The Extended Inline Assembly
The syntax of extended inline asm is similar to the basic inline asm except that it allows specification of input registers, output registers and clobbered space (registers and memory .
The syntax is
asm ( "statements" : output : input : clobbered);
- statements - The asm statements
- output - input constraint-name pairs "constraint" (name), separated by commas.
- input - ouput constraint-name pairs "constraint" (name), separated by commas.
- clobbered - comma separated list of registers clobbered. If you write to memory then "memory" has to inluded as one of the clobbered values. This is to tell gcc that we might have changed some value in the memory which gcc thought it had in a register, It is equivalent to clobbering all of the registers.
The outputs and inputs are referenced by numbers beginning with %0 inside asm statements. The numbering is done based on the order they appear. First numbers are given to output registers and then to input registers.
The constraints for input/output are :-
- g - let the compiler decide which register to use for the variable
- q - load into any available register from eax, ebx, ecx, edx
- r - same as q but includes esi and edi
- a - load into the eax register
- b - load into the ebx register
- c - load into the ecx register
- d - load into the edx register
- f - load into the floating point register
- D - load into the edi register
- S - load into the esi register
For output the contraints are prefixed by "=". The registers can also be accessed directly inside the asm statements, but in extended asm they are prefixed by two % instead of single % like %%eax , %%edx etc.
Lets do the same example function using extended inline asm
void avg() { int i; for(i = 0; i < 5; ++i) { res[i] = (numX[i] + numY[i]); asm("sarl %1 movl %1, %0": "=r"(res[i]) :"r" (res[i]), "memory"); } }
Here we are telling compiler to load res[i] in any register and we can refer that register using %0. The asm generated in this case is following.
_avg:
pushl %ebp
xorl %edx, %edx
movl %esp, %ebp
movl $_res, %ecx
pushl %esi
movl $_numX, %esi
pushl %ebx
movl $_numY, %ebx
L6:
movl (%ebx,%edx,4), %eax # numY
addl (%esi,%edx,4), %eax # numX
movl %eax, (%ecx,%edx,4) # res
/APP
sarl %eax
movl %eax, %eax
/NO_APP
movl %eax, (%ecx,%edx,4) # res
incl %edx # i
cmpl $4, %edx # i
jle L6
popl %ebx
popl %esi
popl %ebp
ret
Lets see some more examples. In above example the input and output were same so we can tell this to compiler using a contraint "0" as follows.
void avg() { int i; for(i = 0; i < 5; ++i) { res[i] = (numX[i] + numY[i]); asm("sarl %0 ": "=r"(res[i]) :"0" (res[i]), "memory"); } }
The asm generated for this case is
_avg:
pushl %ebp
xorl %edx, %edx
movl %esp, %ebp
movl $_res, %ecx
pushl %esi
movl $_numX, %esi
pushl %ebx
movl $_numY, %ebx
L6:
movl (%ebx,%edx,4), %eax # numY
addl (%esi,%edx,4), %eax # numX
movl %eax, (%ecx,%edx,4) # res
/APP
sarl %eax
/NO_APP
movl %eax, (%ecx,%edx,4) # res
incl %edx # i
cmpl $4, %edx # i
jle L6
popl %ebx
popl %esi
popl %ebp
ret
We can write the addition part as follows in extended asm
void avg() { int i; for(i = 0; i < 5; ++i) { asm("movl %1, %0 addl %2, %0 " : "=r" (res[i]) :"r" (numX[i]), "r" (numY[i]): "memory" ); asm("sarl %0" : "=r"(res[i]) :"0" (res[i])); } }
Here we load numX[i] in %1, numY[i] in %2 and the output i.e res[i] is represented as %0. The asm generated in this case is as follows
Collapse_avg:
pushl %ebp
xorl %ecx, %ecx
movl %esp, %ebp
pushl %edi
pushl %esi
movl $_numX, %edi
pushl %ebx
movl $_numY, %esi
movl $_res, %ebx
L6:
movl (%edi,%ecx,4), %eax # numX
movl (%esi,%ecx,4), %edx # numY
/APP
movl %eax, %eax
addl %edx, %eax
/NO_APP
movl %eax, (%ebx,%ecx,4) # res
/APP
sarl %eax
/NO_APP
movl %eax, (%ebx,%ecx,4) # res
incl %ecx # i
cmpl $4, %ecx # i
jle L6
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
We can combine the two asm statements into one as follows
void avg() { int i; for(i = 0; i < 5; ++i) { asm("movl %1, %0 addl %2, %0 sarl %0 " : "=r" (res[i]) :"r" (numX[i]), "r" (numY[i]): "memory" ); } }
The asm generated in this case is as follows
_avg:
pushl %ebp
xorl %ecx, %ecx
movl %esp, %ebp
pushl %edi
pushl %esi
movl $_numX, %edi
pushl %ebx
movl $_numY, %esi
movl $_res, %ebx
L6:
movl (%edi,%ecx,4), %eax # numX
movl (%esi,%ecx,4), %edx # numY
/APP
movl %eax, %eax
addl %edx, %eax
sarl %eax
/NO_APP
movl %eax, (%ebx,%ecx,4) # res
incl %ecx # i
cmpl $4, %ecx # i
jle L6
popl %ebx
popl %esi
popl %edi
popl %ebp
ret
Conclusion
Using extended inline asm of gcc we can write the inline asm code very easily. It provides for easy accessing of local and global variables so you dont have to care about the stack. And you can put inline asm code anywhere between the C code without worrying that you might destroy the asm generated by compiler for the C code.
In my next article I will be talking about the MMX instructions and how to build your own easy to use macros using extended asm for MMX instructions.