$ python stats_opcodes.py file

For Cortex-m3 (check previous post):

At my laptop (x86):

Download the script here.

• IBM DeveloperWorks about Inline asssembly for x86 in Linux
• Linux Documentation Project HOWTO describing GCC Inline Assembly

The syntax may be confusing, if you don’t understand read the documentation available. Each example are an C function with the special construct “asm” for inline assembly code. Examples:

Increment an value:

void inc(int *value) {
 
    asm ( "incl %0"
         :"=a"(*value)
         :"0"(*value)
        );
 
}

Exchange to numbers:

void swap(int *x, int *y) {
 
    asm(""
        : "=a"(*y),"=b"(*x)
        : "a"(*x),"b"(*y)
       );
 
}

Copy an vector:

void vector_copy(int *v_src, int *v_dst, int *count) {
 
    asm("up: lodsl;"
	"    stosl;"
	"loop up;  "
	:
	: "S"(v_src), "D"(v_dst), "c"(*count)
	: "%eax"
	);
 
}

A simple copy:

void copy(int *from, int *to) {
 
     asm ("movl %1, %%eax;"
          "movl %%eax, %0;"
          :"=&r"(*to)
          :"r"(*from));
 
}

A very simple implementation for strncpy:

void _strncpy(char *src, char *dst, int *count) {
 
    asm("cld;"
        "rep movsb;"
        :
        : "S"(src), // 'S' == %esi
	  "D"(dst), // 'D' == %edi
	  "c"(*count)); // 'c' == %ecx
}

If you like to try check this example:

wget http://github.com/maluta/junk/raw/master/asm-inline.c
gcc -Wall -ggdb asm-inline.c -o asm-inline
./asm-inline

• Otimização é importante
• Mas frequentemente: Código legível é mais importante
• Aprenda o que seu compilador faz
  E então deixe-o fazê-lo.

Exemplo. As quatro instruções abaixo fazem a mesma coisa, zeram um registrador da CPU x86, qual é a melhor forma?

Analisando no GDB (x/FMT ADDRESS) temos:

movl  0xb8    0x00    0x00    0x00    0x00
andl  0x83    0xe0    0x00
subl  0x29    0xc0  
xorl  0x31    0xc0
 

E agora? sub ou xor, veja que ambos produzem uma falsa dependência em %eax, mas a CPU sabe como ignorar no caso do xor.

Você sabia?

O compilador sim.

Se você usar o sub na prova seu professor provavelmente irá descontar alguns pontos ou te dar zero…

• Se você fizer uma otimizacão, teste em dados reais.
• Se tornar o código ilegível não tornar o programa drasticamente rápido, não faça.

#nasm -g -f elf programa.asm
#ld programa.o
#gdb -q a.out

Vamos fazer um pequeno programa teste que carrega no registro ecx o valor da variável (var1) e em edx seu endereço:

section .data
 
   var1 dd 40
 
section .text
 
   global _start
 
   _start:
      nop
      nop
      mov   ecx, [var1]
      lea   edx, [var1]
 
   _exit:
      mov   eax, 1
      int   80h

Dentro do gdb:

(gdb) break 11
Breakpoint 1 at 0x80480a1: file teste.asm, line 11.
(gdb) r
Starting program: /home/maluta/coding/a.out
Breakpoint 1, _start () at teste.asm:11
11            nop
(gdb) print var1
$1 = 40
(gdb) info registers ecx edx
ecx            0x0      0
edx            0x0      0

Adicionamos um breakpoint (eu precisei inserir duas instruções nop para o gdb realmente para no ponto) e verificamos os valores de var1, ecx e edx.

(gdb) si
_start () at teste.asm:12
12            mov   ecx, [var1]
(gdb) si
_start () at teste.asm:13
13            lea   edx, [var1]
(gdb) info registers ecx
ecx            0x28     40
(gdb) si
_exit () at teste.asm:16
16            mov   eax, 1
(gdb) info registers edx
edx            0x80490b8        134516920

E por fim, verificamos o conteúdo no endereço definido em edx.

(gdb) print *0x80490b8
$2 = 40

Algumas considerações:

• O Data Diplay Debugger (DDD) é um front-end muito bom para o GDB que pode ser utilizado ao invés da interface de linha de comando.

• O após label _exit há uma chamada a uma syscall (adivinha qual?) do kernel. Passa-se o valor (no registro eax) e chama uma interrupção (80h).  A verdadeira “diversão” está em associar essas syscalls (write, fork, execve, …) mas isto é para outro post… Por enquanto vou lidar com os diferentes modos de endereçamento e operações lógicas e aritméticas.