32 bits vs 64 bits

En estas navideñas fechas reaparezco para mostrar la diferencia entre el código ensamblador de un Hola mundo en C, variando entre un sistema operativo de 32 bits y otro de 64.

El Hola mundo del ejemplo es el clásico en C:

#include

void main (void) {

printf ("¡Hola mundo!");

}


Este es el código ensamblador generado en una Debian Lenny de 32 bits:

.file "holamundo.c"
.section .rodata
.LC0:
.string "\302\241Hola mundo!"
.text
.globl main
.type main, @function
main:
leal 4(%esp), %ecx
andl $-16, %esp
pushl -4(%ecx)
pushl %ebp
movl %esp, %ebp
pushl %ecx
subl $4, %esp
movl $.LC0, (%esp)
call printf
addl $4, %esp
popl %ecx
popl %ebp
leal -4(%ecx), %esp
ret
.size main, .-main
.ident "GCC: (GNU) 4.1.2 20061115 (prerelease) (Debian 4.1.1-21)"
.section .note.GNU-stack,"",@progbits


Y este otro, es lo mismo pero esta vez generado en Debian Lenny de 64 bits:

.file "holamundo.c"
.section .rodata
.LC0:
.string "\302\241Hola mundo!"
.text
.globl main
.type main, @function
main:
.LFB2:
pushq %rbp
.LCFI0:
movq %rsp, %rbp
.LCFI1:
movl $.LC0, %edi
movl $0, %eax
call printf
leave
ret
.LFE2:
.size main, .-main
.section .eh_frame,"a",@progbits
.Lframe1:
.long .LECIE1-.LSCIE1
.LSCIE1:
.long 0x0
.byte 0x1
.string "zR"
.uleb128 0x1
.sleb128 -8
.byte 0x10
.uleb128 0x1
.byte 0x3
.byte 0xc
.uleb128 0x7
.uleb128 0x8
.byte 0x90
.uleb128 0x1
.align 8
.LECIE1:
.LSFDE1:
.long .LEFDE1-.LASFDE1
.LASFDE1:
.long .LASFDE1-.Lframe1
.long .LFB2
.long .LFE2-.LFB2
.uleb128 0x0
.byte 0x4
.long .LCFI0-.LFB2
.byte 0xe
.uleb128 0x10
.byte 0x86
.uleb128 0x2
.byte 0x4
.long .LCFI1-.LCFI0
.byte 0xd
.uleb128 0x6
.align 8
.LEFDE1:
.ident "GCC: (Debian 4.3.2-1) 4.3.2"
.section .note.GNU-stack,"",@progbits


A simple vista parece bastante más largo el de 64 bits, es la primera impresión que nos da si le echamos un vistazo rápido a ambas versiones del código.

Ahora aclaremos que todas las sentencias que empiezan por un punto son directivas del ensamblador es decir, no generan instrucción, simplemente dan información sobre el programa pero no consumen tiempo de CPU.

Sin embargo las líneas que no tienen un punto al principio son las instrucciones del programa, que si consumen tiempo de CPU.

Aunque cada instrucción tenga un consumo de CPU característico, por regla general a más instrucciones, más consumo de CPU como es lógico.


Echando un nuevo vistazo a las dos versiones del Hola mundo, parece que la primera impresión cambia bastante.

Estamos comparando un programa que simplemente imprime una línea en la pantalla, imaginemos la diferencia en un programa un poco más serio por ejemplo, un navegador web ..


Si, es una pena que no se desarrolle más en serio para 64 bits.


Feliz Navidad.