02. NASMx86: partes del código fuente

Publicado por

Continuamos aprendiendo ensamblador. En esta entrada revisaremos las partes que constituyen el código fuente para poder crear libremente nuestros propios programas posteriormente.

Partes del código fuente ensamblador

El código ensamblador se divide en 3 secciones: .data, .text y .bss. Para ejemplificar un poco vamos a trabajar con el ejemplo de la nota anterior.

Sección .data

Esta parte del programa es utilizada para declarar valores constantes o inicializados previo a ejecución. Estos valores no cambian en tiempo de ejecución. La sección .data, del ejemplo de la entrada anterior tenía las siguientes líneas de código:

section .data
msg db 'Hello, world!', 0xa
len equ $ - msg

En este caso tenemos declarados el mensaje (constante) y su longitud (constante también).

Sección .bss

A pesar que no tenemos esta sección de código en nuestro ejemplo, es muy importante su uso ya que en ella se declaran las variables o espacios de memoria cuyo contenido podremos modificar a conveniencia durante la ejecución del programa. Vamos a escribir un par de sentencias que deben de ir en esta sección:

section .bss
numlineas equ 10
buffer resb 10

Con las sentencias anteriores estamos reservando espacio en memoria para una “variable” que inicialmente contendrá el valor 10 decimal y otra “variable” de 10 bytes de tamaño.

Sección .text

En esta sección tenemos las sentencias que le indicarán al ensamblador qué hacer. Debe de contener la directiva global _start para indicarle al kernel en dónde iniciar la ejecución del programa. Tenemos que la sección .text contiene:

section .text
    global _start
_start:
    mov edx,len
    mov ecx,msg
    mov ebx,1
    mov eax,4
    int 0x80
    mov eax,1
    int 0x80

En estas sentencias estamos utilizando los registros de uso general para imprimir el mensaje utilizando interrupciones.

Partes de una sentencia

Una sentencia en ensamblador está constituida, a grandes rasgos, de 4 partes: etiqueta, instrucción, operandos y comentarios.

Las etiquetas son puestas al inicio de una sentencia, son utilizadas para asignar el valor de memoria en que se encuentra el contador en dicha sentencia. Para los identificadores de etiquetas se pueden utilizar caracteres alfanuméricos, _, $, #, @ y ?, o lo que es lo mismo:

\b[a-zA-Z0-1$#@_\?]+\b

O bien:

\b(\w|[#$@?\_])+\b

Nota: si no sabes cómo leer expresiones regulares como las anteriores, te recomiendo leer esto.

Las instrucciones le dicen al procesador qué hacer. Pueden tener o no tener operandos (dependiendo de cuál instrucción sea). Son propias del lenguaje que se utilice. Si te interesa conocer la lista de instrucciones soportadas por NASM, puedes consultar este enlace.

Los operandos, por su parte, son los valores necesarios para completar una instrucción. Estos pueden ser registros, direcciones de memoria, constantes o expresiones, dependiendo de la instrucción que se esté ejecutando.

Finalmente, los comentarios en NASM comienzan con ; y todo lo que se escriba después de este símbolo es ignorado al momento de ensamblar el código fuente. Como cualquier otro lenguaje de programación, solamente son de ayuda para el programador.

Pseudo instrucciones

Las pseudo instrucciones son comandos especiales utilizados por el ensamblador para diversas acciones como:

  • Posicionamiento del programa.
  • Establecer la dirección de memoria en que debe ser ensamblado el programado.
  • Declarar nombres de módulos.
  • Declaración de datos.
  • Opciones de impresión.
  • Definir y llamar macros.
  • Definir el fin del código fuente.

Generalmente estas instrucciones no generan código máquina extra en el programa. Puedes consultar las pseudo instrucciones de NASM también desde este enlace donde se les llama instrucciones especiales.

Macros

Las macros son una secuencia de instrucciones a las que se les asigna un nombre para ser usadas en cualquier parte del código en que se declaren. Las macros inician con %macro; y terminan con %endmacro.

Son definidas por el preprocesador cuando el programa es ensamblado. Estudiaremos macros a profundidad más adelante.

Finalizando…

Con lo visto en esta entrada quedó clara la estructura del código fuente en ensamblador NASM, por ende el ejemplo que utilizamos en el capítulo anterior para verificar que habíamos instalado correctamente el ensamblador también fue comprendido. Espero que te haya servido lo visto hasta ahora. Nos vemos en la siguiente entrada, see ya!

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *