Mostrando entradas con la etiqueta lenguaje. Mostrar todas las entradas
Mostrando entradas con la etiqueta lenguaje. Mostrar todas las entradas

domingo, 11 de enero de 2015

Estructura de un Lenguaje en Ensamblador



Como ya se tiene conocimiento, existen Lenguajes de Alto Nivel y Lenguajes de Bajo Nivel. Los Lenguajes de Alto Nivel poseen un compilador o un intérprete para convertir el programa que se ha declarado en un lenguaje que pueda entender la máquina. A su vez, un Lenguaje de Bajo Nivel tiene un Ensamblador para traducir el código fuente que se desea a lenguaje máquina; sin embargo, esto no es suficiente, ya que se necesita un Enlazador, el cual es un programa que se encarga de convertir el código fuente generado por el Ensamblador en un ejecutable, pues de lo contrario, sólo tendríamos texto plano sin función, de esta forma el proceso se completa.

Comentarios en Lenguaje Ensamblador

Estos van siempre después de “;” (punto y coma), se pueden colocar al principio de una línea o al lado de una línea de instrucción.
                Ejemplo:
1.- ;Todo este texto es un comentario
2.- mov 14,al ;Esto que está a lado de la instrucción también es un comentario
Desde luego, la dimensión de los comentarios no afecta a la ejecución del programa.

Palabras Reservadas
 
Como todo lenguaje de programación, éste también las posee:
a     a)    Nombres de Registros
b     b)      Instrucciones Simbólicas
c     c)       Directivas
d     d)      Operadores

      No se utilizan caracteres especiales.

Estructura de un programa en Lenguaje Ensamblador

title formato -->Indica el título del programa, en éste caso “formato”, desde luego, el título puede incluir mayúsculas, minúsculas y números, pero nunca espacios en blanco.
; ************************************ >>Comentario
               -->Declaración del segmento de Pila
pila segment para stack 'stack' àInicia
                db 64 dub(?) -->Se declara que el segmento ocupe una extensión de 64 bytes
                “(?)”>>Indica que se reservará dicho espacio vacío
pila ends àTermina
; ************************************
>>Declaración del segmento de datos
datos segment para public 'data'
>>Todas las variables que se utilizarán, se declararán en éste sitio
datos ends
; ************************************
codigo segment para public 'code'
     assume cs:codigo, ds:datos, ss:pila >>Se indica que los relacione con los registros
               
ppal proc far >> Es como el “main” de Java, aquí en Ensamblador es el Proceso Principal
>>Por regla general un programa se inicia con “far”, pero también puede tener “near”, sin embargo, “far” se utiliza para el programa principal, mientras que “near” es para un segmento de código que será utilizado dentro del mismo programa; en éste caso, utilizar “near” es como crear un método en un lenguaje de Alto Nivel que después será utilizado por el programa principal cuando sea requerido.
                ; Instrucciones obligatorias
>>Sirven para inicializar el segmento de datos del programa
                ;--------------------
      push ds
      mov ax,0
      push ax
      mov ax,datos
      mov ds,ax
     ;--------------------
                ; Instrucciones del usuario
     ;--------------------
    
     ;--------------------
      ret
                ppal endp >>Fin del proceso principal
codigo ends
end ppal

Después de finalizar un programa en Lenguaje Ensamblador, se guarda con la extensión .asm

Formato:

title formato
; ************************************
pila segment para stack 'stack'
    db 64 dub(?)
pila ends
; ************************************
datos segment para public 'data'
    ;Declaración de variables a ocupar
datos ends
; ************************************
codigo segment para public 'code'
    assume cs:codigo, ds:datos, ss:pila
   
ppal    proc    far
            ; Instrucciones obligatorias
    ;--------------------
     push    ds
     mov    ax,0
     push    ax
     mov    ax,datos
     mov    ds,ax
    ;--------------------
            ; Instrucciones del usuario
    ;--------------------
   
    ;--------------------
     ret
    ppal endp
codigo ends
end ppal 

Debug - Comando Debug en Windows



Manejo de Debug

“debug” es una utilidad interactiva para exploración en bajo nivel de MS-DOS y Windows (hasta 2001) cuyas funciones permiten visualizar memoria, introducir programas en ella así como rastrear su ejecución y desde luego, como traductor de sentencias en Lenguaje Ensamblador a Lenguaje Máquina. Lógicamente, debe ser empleado con sumo cuidado.

Usos:
-->Ensamblar líneas de código
-->Desensamblar código en RAM, ROM y ejecutables
-->Ejecutar paso a paso programas: de esta manera se puede observar el efecto de cada instrucción   sobre las localidades de memoria y registro.
-->Desplegar datos en memoria
-->Verificar estado de los Registros de la CPU

Principales Comandos de Debug

Estos nos permiten realizar diversas operaciones. La mayoría de los mismos al ejecutar una acción, retornan al indicador, sin embargo, si la instrucción a ejecutar es grande en código, se puede detener con CTRL-Pausa o interrumpirse con CTRL-C para volver.

Comando
Descripción
A
Ensamblar (Convertir Instrucciones Simbólicas a Lenguaje Máquina)
D
Mostrar contenido en memoria (puede especificarse)
E
Introducir datos en memoria iniciando en una localidad específica
G
Corre el programa ejecutable cargado en memoria en ese momento
N
Nombrar un programa
P
Ejecuta un conjunto de instrucciones relacionadas
Q
Sale de debug
R
Muestra el contenido de uno o más registros
T
Rastrea la ejecución de una instrucción
U
Desensamblar (Convertir Lenguaje Máquina a Instrucción Simbólicas)
W
Graba un programa en disco
XA
Asigna memoria expandida
XD
Designa memoria expandida
XM
Asigna páginas de memoria expandida
XS
Muestra los estados de la memoria expandida

Reglas de Comandos Debug
1.- No existe distinción en mayúsculas y minúsculas
2.- Los espacios que se ingresan con la finalidad de separar parámetros son únicos (es decir, sólo se puede teclear uno entre cada parámetro, no puede haber dos por cada uno debido a que lo desconoce)

Despliegue de Debug



*Importante: Debug sólo es soportado por Arquitectura de 32 Bits, para las Arquitecturas de 64 Bits se recomienda emplear un Simulador como DOSBox para poder ejecutar debug así como instrucciones de Lenguaje Ensamblador y emplear Turbo Assembler en caso de querer ensamblar los programas que se generen. También pueden utilizar una máquina virtual de 32 Bits.