El gcc:

El gcc es el compilador de la GNU para C, básicamente, aunque soporta varios lenguajes, como
el ANSI C, el K&R C, el C++ y el Objective C.
El gcc implementa las cuatro fases de la compilación. Además existe una versión extendida
(egcs) que tiene capacidad para compilar en otros lenguajes como Fortran 77, C++.

El gdb:

Para todo desarrollo, siempre resulta útil la existencia de un 'debugger' (matabichos, literalmente),
para poder evaluar paso a paso todas las instrucciones del programa.
Para poder usar el gdb con el programa compilado en C hará falta compilarlo con la opción -g del gcc,
pues el gdb necesita algo más de información que se genera en un fichero aparte.

Make:

La herramienta make es una herramienta estándar en todo sistema Unix.
Permite efectuar una compilación inteligente de programas, evitando compilar lo supérfluo.
Para ello se basa en la sintaxis específica de un archivo llamado Makefile, que configura la forma de
actuar de make, a la hora de llamar al compilador, las opciones, etc.
Generalmente se usa para compilar código C.

Formato de los ejecutables:

Linux soporta dos formatos de ejecutables, el a.out, que fue el primero, y el ELF (Executable and Linking
Format).
a.out (Assembled OUTput) es el formato de las primeras versiones tanto de Linux como de Unix.
Sin embargo, hacia 1994, el equipo de desarrolladores de Linux decidió migrar de formato hacia el ELF,
pues es mucho más flexible y manejable que el a.out.
Este formato fue inicialmente desarrollado y diseñado por el USL (Unix System Laboratories), y se utiliza
en los sistemas Unix del tipo SVR4 y Solaris 2.x

Fases de la compilación:

Las fases son cuatro, a partir del código, ejemplo.c, se genera el ejecutable (en principio, a.out, aunque
será mejor compilar con formato ELF):

Preprocesador (cpp)
--> C completo
Compilador (cc1)
--> Programa en ensamblador
Ensamblador (as)
--> Código objeto
Enlazador (o linkador7.1)
--> ejecutable (a.out ó ejemplo)

Los nombres entre paréntesis son los de las herramientas encargadas de hacer cada proceso.
Sin embargo, si ejecutamos gcc, éste realizará todas las fases en una sola.
Si ejecutamos el gcc con la opción -v, recibiremos en pantalla información de las cuatro fases de
compilación.

Ejemplo. Programación en C:

Como ejemplo de programación en C, vamos a compilar en nuestra máquina el ya requetetípico
programa de 'Hola Mundo'.

Para ello necesitaremos tener en nuestro sistema el gcc (el compilador GNU de C), las cabeceras
del kernel, así como quizá alguna que otra librería específica (como las ncurses para el manejo de
terminales).

El código es el siguiente

//
//hola.c
//
#include <stdio.h>
main()
{
printf("\n\tHola Mundo!\n");
}

Para compilarlo seguimos el siguiente orden:

[todolinux.com]$ gcc hola.c -o hola

donde el flag -o indica el nombre del archivo binario ejecutable que queremos que genere el compilador.
Una vez hecho, basta con teclear hola para ver lo siguiente:

[todolinux.com]$ hola

Hola Mundo!

[todolinux.com]$

Si ejecutamos el gcc con el flag v para que sea 'verbose', la salida es la siguiente:

[todolinux.com]$ gcc -v hola.c -o hola
21:16:33Reading specs from /usr/lib/gcc-lib/i486-linux/2.7.2.3/
specs gcc version 2.7.2.3
/usr/lib/gcc-lib/i486-linux/2.7.2.3/cpp -lang-c -v -undef -D__GNUC__=2
-D__GNUC_MINOR__=7 -D__ELF__ -Dunix -Di386 -Dlinux -D__ELF__ -D__unix__
-D__i386__ -D__linux__ -D__unix -D__i386 -D__linux -Asystem(unix)
-Asystem(posix) -Acpu(i386) -Amachine(i386) hola.c /tmp/cca07016
GNU CPP version 2.7.2.3 (i386 Linux/ELF)
#include "..." search starts here:
#include <...> search starts here:
/usr/local/include
/usr/i486-linux/include
/usr/lib/gcc-lib/i486-linux/2.7.2.3/include
/usr/include
End of search list.
/usr/lib/gcc-lib/i486-linux/2.7.2.3/cc1 /tmp/cca07016 -quiet
-dumpbase hola.c -version -o /tmp/ccb07016
GNU C version 2.7.2.3 (i386 Linux/ELF) compiled by GNU C version 2.7.2.3.
as -V -Qy /tmp/ccb07016 -o /tmp/ccc07016
GNU assembler version 2.9.1 (i486-linux), using BFD version 2.9.1.0.19
ld -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o hol
/usr/lib/crt1.o /usr/lib/crti.o
/usr/lib/gcc-lib/i486-linux/2.7.2.3/crtbegin.o
-L/usr/lib/gcc-lib/i486-linux/2.7.2.3 /tmp/ccc07016 -lgcc -lc -lgcc
/usr/lib/gcc-lib/i486-linux/2.7.2.3/crtend.o /usr/lib/crtn.o
[todolinux.com]$

Como vemos, aparecen explícitas las cuatro fases de compilación que ejecuta el gcc por
nosotros, buscando cabeceras del kernel, enlazando código, etc.


Bueno, espero que esto sirva como orientación, ya agregaré otros ejemplos y en especial la
compilación del kernel :).

Home Page