Machine-Level Programming XI: inline Assembly Comp 21000: Introduction to Computer Systems & Assembly Lang On-Line resources* See see http://www.codeproject.com/Articles/15971/Using-Inline-Assembly-in-C-C And

Today Inline assembly Examples Exercises Assembly from scratch

Why use assembly? Assembly can express very low-level things: you can access machine-dependent registers and I/O you can control the exact code behavior in critical sections that might otherwise involve deadlock between multiple software threads or hardware devices you can break the conventions of your usual compiler, which might allow some optimizations (like temporarily breaking rules about memory allocation, threading, calling conventions, etc) you can build interfaces between code fragments using incompatible conventions (e.g. produced by different compilers, or separated by a low-level interface) you can get access to unusual programming modes of your processor (e.g. 16 bit mode to interface startup, firmware, or legacy code on Intel PCs) you can produce reasonably fast code for tight loops to cope with a bad non-optimizing compiler (but then, there are free optimizing compilers available!) you can produce hand-optimized code perfectly tuned for your particular hardware setup, though not to someone else's you can write some code for your new language's optimizing compiler (that is something that very few people will ever do, and even they not often) i.e. you can be in complete control of your code From the linux assembly howto

Why use assembly? Assembly can express very low-level things: there are a number of special registers storing process state information that the operating system must access. There are either special instructions or special memory locations for performing input and output operations. Even for application programmers, there are some machine features, such as the values of the condition codes, that cannot be accessed directly in C.

Why use assembly? As Charles Fiterman says on comp.compilers about human vs computer-generated assembly code: The human should always win and here is why. First the human writes the whole thing in a high level language. Second she profiles it to find the hot spots where it spends its time. Third she has the compiler produce assembly for those small sections of code. Fourth she hand tunes them looking for tiny improvements over the machine generated code. The human wins because she can use the machine.

Why use assembly? Speed Be careful! Optimizing compilers are almost always better! useful when you know an assembly language instruction that can replace a library call Example: transcendental function computation has macros for some inline assembly sequences Example: if spend most of the time in a loop computing the sine and cosine of the same angles, could use the fsincos assembly function We’ll see an example later See this page for bit hacking tricks: http://graphics.stanford.edu/~seander/bithacks.html

Speed example Find the most significant bit. int main (int argc, char* argv[]) { int max = atoi (argv[1]); int i, number; unsigned position; volatile unsigned result; /* Repeat the operation for a large number of values. */ for (number = 1; number <= max; ++number) { /* Repeatedly shift the number to the right, * until the result is zero. Keep count of the number of * shifts this requires. */ for (i = (number >> 1), position = 0; i != 0; ++position) i >>= 1; /* The position of the most significant set bit is the number of shifts we needed after the first one. */ result = position; } printf("most significant bit position is: %d\n", result); return 0; Find the most significant bit. int main (int argc, char* argv[]) { int max = atoi (argv[1]); int number; unsigned position; volatile unsigned result; /* Repeat the operation for a large number of values. */ for (number = 1; number <= max; ++number) { /* Compute the position of the most significant set bit using the bsrl assembly instruction. */ asm ("bsrl %1, %0" : "=r" (position) : "r" (number)); result = position; } printf("Most significant 1 is at position: %d\n", result); return 0; } Will find most significant bit of 100,000,000 numbers but only print the msb of the last

bsr: bit scan reverse Searches the source operand (second operand) for the most significant set bit (1 bit). If a most significant 1 bit is found, its bit index is stored in the destination operand (first operand). The source operand can be a register or a memory location; the destination operand is a register. The bit index is an unsigned offset from bit 0 of the source operand. If the content source operand is 0, the content of the destination operand is undefined.

Timing this barr/Student/comp210/resources/assem/findMSB.c barr/Student/comp210/resources/assem/findMSB2.c barr@Comp390-WG1: time msb 100000000 most significant bit position is: 26 real 0m1.132s user 0m1.124s sys 0m0.004s barr@Comp390-WG1: time msb2 100000000 Most significant 1 is at position: 26 real 0m0.115s user 0m0.112s sys 0m0.000s The command “time” will time the program that you run Program using shift Both programs compiled with optimization level –O1 Program using inline assembly: almost 10 times faster with optimization level –O7 first program still took 1.06s!

inline assembly code* Example: mov instruction /* put this line in your C program*/ asm("assembly code"); /* alternative syntax */ __asm__ ("assembly code"); Example: mov instruction asm("movl %rbx, %rax"); /* moves the contents of ebx register to eax */ __asm__("movb %ch, (%rbx)"); /* moves the byte from ch to the memory pointed by ebx */ * see http://www.codeproject.com/Articles/15971/Using-Inline-Assembly-in-C-C

inline assembly More sophisticated assembly For more than one assembly instruction, use semicolon at the end of each instruction of inserted code see example on next slide

Example 0 #include <stdio.h> int main() { /* Add 10 and 20 and store result into register %eax */ __asm__ ( "mov $10, %rax;" "mov $20, %rbx;" "add %rbx, %rax;" ); /* Subtract 20 from 10 and store result into register %eax */ "sub %rbx, %rax;" /* Multiply 10 and 20 and store result into register %eax */ "imul %rbx, %rax;" return 0 ; } compile with –O1 flag trace in gdb to see registers change. See /home/barr/Student/comp210/resources/assem/inline1.c

Extended inline assembly Idea In extended assembly, we can also specify the operands can specify the input registers, output registers and a list of clobbered registers. If there are no output operands but there are input operands, we must place two consecutive colons surrounding the place where the output operands would go. Can omit list of clobbered registers to use, GCC and GCC’s optimization scheme will take care of the reg. In general, it’s a bad idea to omit these asm ( "assembly code" : output operands /* optional */ : input operands /* optional */ : list of clobbered registers /* optional */ );

Example 1 The variable "val" is kept in a register Assm instr Output operands asm ("movq %%rax, %0;" : "=r" ( val )); The variable "val" is kept in a register val is a C variable that must be declared earlier in the C program the value in register %rax is copied onto that register, and the value of "val" is updated into the memory from that register. note that rax is preceded by 2 percent signs differentiate from a asm parameter (asm works like printf) see ~barr/Student/Comp210/Resources/assem directory for all examples asm ( "assembly code" : output operands /* optional */ : input operands /* optional */ : list of clobbered registers /* optional */ );

Example 1 (continued) asm ("movq %%rax, %0;" : "=r" ( val )); the %0 indicates the first operand of asm, it is associated with the first parameter, i.e., val (similar to printf) “=r” indicates a register constraint see chart on next page for all possible register specifications “r” indicates that gcc may keep the variable in any available General Purpose Register (see next slide) the “=“ indicates write only mode. If our instruction can alter the condition code register, we have to add "cc" to the list of clobbered registers. "g" : Any register, memory or immediate integer operand is allowed, except for registers that are not general registers.

register specifiers r register R General register (RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP) q General register for data (RAX, RBX, RCX, RDX) f Floating point reg a %rax,%eax, %ax, %al b %rbx, %ebx, %bx, %bl c %rcx, %ecx, %cx, %cl d %rdx, %edx, %dx, %dl S %rsi, %esi, %si D %rdi, %edi, %di

Example 1 continued long no = 100, val ; asm ("movq %1, %%rbx;" "movq %%rbx, %0;" : "=r" ( val ) /* output */ : "r" ( no ) /* input */ : ”%rbx" /* clobbered register */ ); Two variables are declared in the C code, no and val %0 is the first operand to asm and thus refers to the C variable val (the output variable) %1 is the second operand and thus refers to the C variable no (the input variable) “=r” and “r” say that gcc can use any registers to store the corresponding variable (either val or no ) the clobbered variable is %rbx so gcc should not use that variable anywhere else. See home/barr/Student/comp210/resources/assem/inline1.c

Example 2 No variables are declared in the C code __asm__ ( "movq $10, %rax;" "movq $20, %rbx;" "addq %rbx, %rax;" ); /* Subtract 20 from 10 and store result into register %eax */ "subq %rbx, %rax;" /* Multiply 10 and 20 and store result into register %eax */ "imulq %rbx, %rax;" No variables are declared in the C code Arithmetic performed with registers No values are moved back into C variables. So the result is never used/printed. See home/barr/Student/Comp210/Resources/assem/inline2.c

Example 3 The C code declares three variables: arg1, arg2, add long arg1, arg2, add ; arg1 = 10; arg2 = 25; __asm__ ( "addq %%rbx, %%rax;" : "=a" (add) /* output */ : "a" (arg1), "b" (arg2) ); /* input */ The C code declares three variables: arg1, arg2, add The input variables will use %rax (for arg1) and %rbx (for arg2) the output variable is add and will use register %rax Note that don’t need the position parameters (%0, %1) if specify registers for the input/output variables. no clobber register is set; gcc can determine See home/barr/Student/comp210/resources/assem/inline3.c

Example 4 Example 4 idivq S # Signed divide #include <stdio.h> int main() { long arg1, arg2, add, sub, mul, quo, rem ; printf( "Enter two integer numbers : " ); scanf( "%ld%ld", &arg1, &arg2 ); /* Perform Addition, Subtraction, Multiplication & Division */ __asm__ ( "addq %%rbx, %%rax;" : "=a" (add) : "a" (arg1) , "b" (arg2) ); __asm__ ( "subq %%rbx, %%rax;" : "=a" (sub) : "a" (arg1) , "b" (arg2) ); __asm__ ( "imulq %%rbx, %%rax;" : "=a" (mul) : "a" (arg1) , "b" (arg2) ); __asm__ ( "movq $0x0, %%rdx;" "movq %2, %%rax;” "idivq %%rbx;" : "=a" (quo), "=d" (rem) : "g" (arg1), "g" (arg2) ); printf( "%ld + %ld = %ld\n", arg1, arg2, add ); printf( "%ld - %ld = %ld\n", arg1, arg2, sub ); printf( "%ld * %ld = %ld\n", arg1, arg2, mul ); printf( "%ld / %ld = %ld\n", arg1, arg2, quo ); printf( "%ld %% %ld = %ld\n", arg1, arg2, rem ); return 0 ; } Example 4 Example 4 idivq S # Signed divide R[%rdx] R[%rdx]:R[%rax] mod S; R[%rax] R[%rdx]:R[%rax] / S See home/barr/Student/comp210/resources/assem/inline2.c

Example 4 In-class exercise idivq S # Signed divide #include <stdio.h> int main() { long arg1, arg2, arg3, rslt; printf( "Enter three integer numbers : " ); scanf( "%ld%ld%ld", &arg1, &arg2, &arg3 ); /* Change this line to assembly */ rslt = arg1 + 2 * arg2 - arg3 / 2; printf( "%ld + 2 * %ld – %ld / 2 = %ld\n", arg1, arg2, arg3, rslt ); return 0 ; } Example 4 In-class exercise idivq S # Signed divide R[%rdx] R[%rdx]:R[%rax] mod S; R[%rax] R[%rdx]:R[%rax] / S

Example 4 Example revisited why use inline assembly? #include <stdio.h> #include <stdlib.h> int main (int argc, char* argv[]) { long max = atoi (argv[1]); long number; long i; unsigned position; volatile unsigned result; /* Repeat the operation for a large number of values. */ for (number = 1; number <= max; ++number) { /* Repeatedly shift the number to the right, until the result is zero. Keep count of the number of shifts this requires. */ for (i = (number >> 1), position = 0; i != 0; ++position) i >>= 1; /* The position of the most significant set bit is the number of shifts we needed after the first one. */ result = position; } // end outer for loop return 0; } // end main Example 4 Example revisited why use inline assembly? no assembly in this code See : /home/barr/Student/comp210 /resources/assem/findMSB.c % gcc -O2 –o msb findMSB.c % time ./msb 250000000 most significant bit position is: 26 real 0m1.132s user 0m1.124s sys 0m0.004s

Example 4 Example revisited why use inline assembly? #include <stdio.h> #include <stdlib.h> int main (int argc, char* argv[]) { long max = atoi (argv[1]); long number; unsigned position; volatile unsigned result; /* Repeat the operation for a large number of values. */ for (number = 1; number <= max; ++number) { /* Compute the position of the most significant set bit using the bsrl assembly instruction. */ asm (“bsrl %1, %0” : “=r” (position) : “r” (number)); result = position; } // end for loop return 0; } Example 4 Example revisited why use inline assembly? assembly used for inner loop See: /home/barr/Student/ Comp210/Resources/assem/ findMSB2.c bsr: Scans source operand for first bit set. Sets ZF if a bit is found set and loads the destination with an index to first set bit. Clears ZF is no bits are found set. BSF scans forward across bit pattern (0-n) while BSR scans in reverse (n-0). %gcc -O2 –o msb2 findMSB2.c % time ./msb2 250000000 Most significant 1 is at position: 26 real 0m0.115s user 0m0.112s sys 0m0.000s Compare to the 0m1.124s user of the previous C only example!

Volitile If our assembly statement must execute where we put it, (e.g. must not be moved out of a loop as an optimization), put the keyword "volatile" or "__volatile__" after "asm" or "__asm__" and before the ()s. asm volatile ( "...;” "...;" : ... ); __asm__ __volatile__ ( "...;"

Example 4 Example 5 Compute GCD with Euclid’s Algm gcd.c #include <stdio.h> long gcd( long a, long b ) { long result ; /* Compute Greatest Common Divisor using Euclid's Algorithm */ __asm__ __volatile__ ( "movq %1, %%rax;" "movq %2, %%rbx;" "CONTD: cmpq $0, %%rbx;" "je DONE;" "xorq %%rdx, %%rdx;" "idivq %%rbx;" "movq %%rbx, %%rax;" "movq %%rdx, %%rbx;" "jmp CONTD;" "DONE: movq %%rax, %0;" : "=g" (result) : "g" (a), "g" (b) ); return result ; } int main() { long first, second ; printf( "Enter two integers : " ) ; scanf( "%ld%ld", &first, &second ); printf( "GCD of %ld & %ld is %ld\n", first, second, gcd(first, second) ) ; return 0 ; Example 4 Example 5 Compute GCD with Euclid’s Algm gcd.c Note that we can put labels and jump to them! Note that we can put several asm instructions in one __asm__ function call Do NOT use the optimization parameter when you compile this!

In-class exercise 2 convert the for loop to assembly code #include <stdio.h> int main() { int x, y, rslt, rtnval; int i; printf("Enter two integers\n"); rslt = scanf("%d%d", &x, &y); /* change into assembly code */ rtnval = 0; for(i = 0; i < y; i++) rtnval += x; } /* end change */ printf("%d * %d = %d\n", x, y, rtnval); return 0; In-class exercise 2 convert the for loop to assembly code (should be no more than 11 lines of assembly code)