Esta guía no pretende ser un texto que trate de forma exhaustiva los por menores de los métodos de enlace, su asociación con la interfaz binaria de la aplicación específica de una arquitectura ABI x86-64 ABI ARM, así como la sintaxis del GNU LD, sino que empleará un enfoque meramente práctico para la resolución de los ejercicios requeridos por la materia, haciendo incapie en algunos conceptos útiles que deben ser comprendidos para la formación del futuro ingeniero.

La guía solo cubre la sintaxis GNU LD, la ABI x86-64 desarrollada por el Tool Interface Standards (TIS) del)UNIX System Laboratories. Para una mejor comprensión de los conceptos que se brindarán, el lector debe estar familirizado con los siguiente temas

• Etapas de la generación de un binario ejecutable (ensamblar, compilar, preprocesar, enlazar)
• Executable and Linking Format (ELF)
• Manejo básico del lenguaje ensamblador.

El enlazador tiene por objetivo combinar varios fragmentos de código y datos en un único fichero binario, el cual puede presentar la misma organización de la memoria en la cual se carga, por ejemplo una ROM, o diferir virtualmente como es el caso de la RAM. Vale la pena aclarar que también es posible que la organizacion de la memoria de carga (ROM) coincida con la virtual (RAM).

Lo expresado anteriormente puede comprenderse claramente mediante el siguiente ejemplo.

Se desea realizar un programa que modifique 4MB de memoria a '0', que previamente pueden estar inicializados 
en cualquier valor, sabiendo que el sistema solo cuenta con una ROM de 1kB y una RAM de 8MB.
Antes de continuar leyendo reflexione sobre lo siguiente
  * Elabore mentalmente un programa que cumpla con el objetivo propuesto, sabiendo que el sistema no dispone de ningún SO.  
  * ¿Donde se encuentra el programa durante la ejecución?
  * ¿Como llegó a la ubicación de la respuesta anterior? 
  * ¿Que tamaño, aunque más no sea basandose en el tamaño de los datos, estima que tendría el programa?

Si la propuesta es:

#define MEM_4MB         (4*1024*1024) 
char mem_ptr_a[MEM_4MB]={'C','h','r','i','s','t','i','a','N'};      /*Algunos elementos inicializados a algun valor*/
 
int main(void)
{
   unsigned int contador;
 
   for(contador=0; contador<MEM_4MB; contador++)
   {
      mem_ptr_a[contador]=0;
   }
} 

Resulta evidente que el binario generado ocupará al menos 4MBytes, por lo cual no cabrá en la ROM del sistema. Para solventar el problema mencionado se propone:

char mem_ptr_c[]="ChristiaN";
 
int main(void)
{
   unsigned int contador;
 
   for(contador=0; contador<MEM_4MB; contador++)
   {
      mem_ptr_c[contador]=0;
   }
} 

El código propuesto genera un binario con el siguiente mapa de memoria simplificado.

A partir del mismo se aprecia que no es posible utilizar este binario como código de arranque de nuestro sistema ya que la familia de procesadores Intel IA32 requieren que el mismo se encuentre a partir de la dirección 0xFFFF0, es decir, que el mapa de memoria necesario seria

Como puede observarse no solo es necesario alterar el orden de la sección de datos y código sino que también, se deben modificar las direcciones de los punteros de datos y las llamadas a función.

Para resolver esta clase de problemas se utiliza el enlazador. Sin más preámbulos a continuación se explicará como realizar estas operaciones.

Al igual que muchas otras herramientas GNU, conocidas en la jerga como binutils, el enlazador ld se lanza a través de la línea de comandos utilizando el siguiente formato

ld <opciones> fichero_de_entrada_1 fichero_de_entrada_2 fichero_de_entrada_n -o fichero_de_salida

Dentro de las múltiples opciones que presenta la herramienta, las cuales pueden listarse mediante man -a ld, vale la pena mencionar -T, la cual permite indicarle al ld que utilice un script proporcionado por el usuario para enlazar los fiheros ELF de entrada. Este script conocido como linker script o lds por su extensión permite indicarle al ld como debe organizar las diferentes secciones que compondrán el fichero de salida, así como también en que dirección deberán ser referenciadas y/o ubicadas físicamente las mismas. Estas direcciones como se explicará a continuación se conocen como VMA y LMA respectivamente. El enlazador asocia cada sección de un programa a dos direcciones de memoria, que pueden coincidir o no:

• Virtual [VMA] : es aquella donde el binario copia los datos modificables y en algunos casos una parte de si mismo para su posterior ejecución, por lo general se la asocia a la memoria RAM.
• De Carga {LMA] : es aquella en donde se almacena el binario para su ejecución inicial, generalmente se la asocia a la memoria ROM.

Un fichero linker script puede llegar a ser tan críptico que se requieran varios minutos en comprender su objetivo, sin embargo conceptualmente se debe comprender que no es más que un agrupamiento de secciones y sus respectivas direcciones VMA y LMA, las cuales se gestionan mediante el contador de posición cuyo símbolo es el punto[.]. La función de este último es simplemente disponer de un índice que permite gestionar los desplazamientos relativos y/o absolutos de una sección respecto a otra. Si bien existe una gran cantidad de opciones y comandos disponibles para un linker script, la presente guía se focalizará en el siguiente modelo, el cual se explicará con ejemplos en los apartados siguientes.

SECTIONS
{
   section [direccion] [(tipo)] :
   [AT(lma)] [ALIGN(alinear_la_seccion)] [SUBALIGN(alinear_subseccion)]
   {
   comandos_para_la_seccion
   } [>region] [AT>lma_region] [:direccion_fisica :direccion_fisica ...] [=expresion_para_el_relleno_de_espacios]
}

El siguiente ejemplo tiene por objetivo mostrar como es posible modificar las direcciones absolutas de las variables, es decir el equivalente a la directiva ORG de NASM. Como se puede apreciar las direcciones se desplazan a partir de la dirección 0x08000. El fichero de enlace es mi_linker_script.lds

SECTIONS
{
   . = 0x08000;
}

Los parámetros del enlazador

ld -z max-page-size=0x01000 --oformat=binary -m elf_i386 -T mi_linker_script.lds -e Inicio fichero.elf -o fichero.bin

El código y sus salidas

+--------------------------------+-----------------------------------------------------------------------------------+
|.asm                            | .lst                                                         |.bin                |
+--------------------------------+--------------------------------------------------------------+--------------------+
| 1 bits 32                      |  1                             bits 32                       |                    |
| 2                              |  2                                                           |                    |
| 3 global Inicio                |  3                             global Inicio                 |                    |
| 4                              |  4                                                           |                    |
| 5 dato:   dw 0x1234            |  5 00000000 3412              dato:  dw 0x1234               | 34 12              |
| 6                              |  6                                                           |                    |
| 7 Inicio:                      |  7                             Inicio:                       |                    |
| 8   xor edi, edi               |  8 00000002 31FF                  xor edi, edi               | 31 ff              |
| 9   mov dword edi, 0x01        |  9 00000004 BF01000000            mov dword edi, 0x01        | bf 01 00 00 00     |
|10   xor esi, esi               | 10 00000009 31F6                  xor esi, esi               | 31 f6              |
|11   mov dword esi,0x03         | 11 0000000B BE03000000            mov dword esi,0x03         | be 03 00 00 00     |
|12   mov dword [variable], 0x04 | 12 00000010 C705[2E000000]0400-   mov dword [variable], 0x04 | c7 05 2e 80 00     |
|13                              | 13 00000018 0000                                             | 00 04 00 00 00     |
|14   xor eax, eax               | 14 0000001A 31C0                  xor eax, eax               | 31 c0              |
|15   add eax, edi               | 15 0000001C 01F8                  add eax, edi               | 01 f8              |
|16   add eax, esi               | 16 0000001E 01F0                  add eax, esi               | 01 f0              |
|17   add dword eax, [variable]  | 17 00000020 0305[2E000000]        add dword eax, [variable]  | 03 05 2e 80 00 00  |
|18   mov dword [resultado], eax | 18 00000026 A3[2C000000]          mov dword [resultado], eax | a3 2c 80 00 00     |
|19   hlt                        | 19 0000002B F4                    hlt                        | f4                 |
|20                              | 20                                                           |                    |
|21   resultado:  dw 0x9876      | 21 0000002C 7698                  resultado:  dw 0x9876      | 76 98              |
|22   variable:   resd 1         | 22 0000002E <res 00000004>        variable:   resd 1         | 00 00 00 00        |
+--------------------------------+--------------------------------------------------------------+--------------------+

— ChristiaN 2015/03/12 20:41

• ¡No tengo conocimiento de ensamblador, pero si de C ¿puedo leer esta guía?

Si dispone de un buen conocimiento de ELF y de como C gestiona los diferentes tipos de datos, los conceptos brindados serán comprensibles

• ¡No tengo conocimiento de ensamblador ni de si de C, pero se muchisimo de Java ¿puedo leer esta guía?

Si puede leerla, pero no la entenderá

• ¡Soy especialista en Phyton, Visual Basic y #C ¿puedo leer esta guía?

• GNU LD (enlazador utilizado por defecto en la Cátedra)
• ABI x86-64
• Guía de supervivencia de ensamblador