Make your own free website on Tripod.com

Práctica 1: Captura y ensamblado de programas en Nasm


En esta práctica se repasarán los pasos necesarios para convertir un archivo fuente en un programa ejecutable. Cómo ya sabe, se debe capturar el código fuente, después ensamblar y finalmente ligar para obtener un ejecutable.



Supongamos que en el archivo "fibo1.asm" se tiene capturado el siguiente programa en bajo nivel:

        ;Archivo: fibo1.asm
        ;pseudocodigo
        ;inicio:
        ;   x=0
        ;   y=1
        ;   z=0
        ;   repite:
        ;        z=x+y
        ;        x=y
        ;        y=z
        ;   hasta (z>1000)
        ;fin
        ;-------------------
        ; x=ax,y=bx, z=cx
        ;--------------------
        segment pila stack
        resb 512
        segment codigo code
        ; Inicio
        ..start:
                mov ax,0 ; x=0
                mov bx,1 ; y=1
                mov cx,0 ; z=0
        repite:
                mov cx,ax ; z=x+y
                add cx,bx
                mov ax,bx ; x=y
                mov bx,cx ; y=z
                cmp cx,1000 ;hasta (z>1000)
                jbe repite ;
        ;fin
        mov ax,4c00h
        int 21h

Ensamblado y ligado:

Para ensamblar el código fuente y generar el archivo objeto se debe teclear:

   nasm -f obj fibo1.asm

Para generar el ejecutable a partir del archivo objeto (ligar), tecleamos:

   link fibo1.obj

Tomando como guía el ejemplo anterior, convierte a código en ensamblador (incluye definir segmentos de pila y código), captura, ensambla y liga los siguientes pseudocódigos:

  1.        Inicio:
            ax=30
            bx=10
            sub ax,bx
            Si (ax <= 0)
                ax = 0
            Fin_si
            add ax,bx
           Fin.
      
  2.        Inicio:
            ax=0
            bx=10
            cx=0
            mientras(cx < bx)
                inc cx
                add ax,bx
            fin_mientras
           Fin.
  3.        Inicio:
            ax=0
            cx=1
            Mientras (cx < 100)
               ax=ax+cx
               inc cx
            Fin_mientras
           Fin.
  4.        Inicio:
            ax=32000
            bx=8
            mul bx
            Si (dx > 0)
                stc
            Fin_si
           Fin.