Practicas Unidad 3 - JoseCorreaMorales/lenguajes-de-interfaz GitHub Wiki

la función "AND" en lenguaje ensamblador es una operación lógica que compara dos bits y devuelve un resultado en función de sus valores, y se utiliza para realizar comparaciones bit a bit.

El objetivo de este programa es demostrar el uso de la función AND, en lenguaje ensamblador para realizar operaciones lógicas simples y mostrar el resultado en la salida estándar.

En lenguaje ensamblador sintaxis Intel, la función "AND" es una operación lógica que se utiliza para comparar dos bits y producir un resultado en función de sus valores

A continuación se detallan los puntos mas importante del siguiente código

section .data

msg1 db 'El resultado es ' 0x0A, 0x0D   

msg1Len equ $-msg1


section .bss
resultado resb 1 
resultadoLen equ $-resultado


section .text

global _start

_start:

mov al, 2
mov bl, 1

and al, bl

and al, 48
mov [resultado], al


mov eax, 4
mov ebx, 1
mov ecx, msg1
mov edx, Msg1Len
int 0x80

mov eax, 4
mov ebx, 1
mov ecx, resultado
mov edx, resultadoLen
int 0x80

mov eax, 1
mov eax, 0
int 0x80

En la línea "and al, bl" se realiza una operación lógica "AND" a nivel binario entre los valores de los registros AL y BL. Esta operación lógica se realiza bit a bit, es decir, se compara el valor del primer bit de AL con el valor del primer bit de BL, luego el valor del segundo bit de AL con el valor del segundo bit de BL, y así sucesivamente hasta llegar al octavo bit.

En este caso, como los valores de AL y BL son 2 y 1, respectivamente, su representación binaria es la siguiente:

• AL = 00000010
• BL = 00000001 Al realizar la operación "AND" bit a bit, se obtiene el siguiente resultado:

00000010 AND 00000001 = 00000000 Es decir, el resultado de la operación es cero, ya que el primer bit de AL y el primer bit de BL tienen valores diferentes. Todos los demás bits también tienen valores diferentes, por lo que el resultado de la operación lógica "AND" entre AL y BL es cero en todos los bits.

Por lo tanto, después de esta operación, el valor de AL sigue siendo 00000010 y el valor de BL sigue siendo 00000001.

En resumen, la salida del código será "El resultado es " seguido de un salto de línea y un retorno de carro, y luego se imprimirá el valor binario 0. Esto se debe a que se realizó una operación lógica "AND" a nivel binario entre los valores de los registros AL y BL, que resultó en cero, y este valor se guardó en la variable "resultado" y se imprimió en la consola.

Es importante tener en cuenta que la función "AND" no modifica ninguno de los operandos originales, sino que solo realiza la operación lógica y almacena el resultado en el destino especificado.

En lenguaje ensamblador sintaxis Intel, la función "AND" es una operación lógica que se utiliza para comparar dos bits y producir un resultado en función de sus valores. La operación "AND" devuelve un valor de "1" si ambos bits de entrada tienen el valor de "1", de lo contrario devuelve un valor de "0".

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

En lenguaje ensamblador con sintaxis Intel, la función OR se utiliza para realizar una operación lógica OR (O inclusivo) entre dos operandos y establecer el resultado en un registro o una ubicación de memoria especificada.

El objetivo de este programa es demostrar el uso de la función OR, en lenguaje ensamblador para realizar operaciones lógicas simples y mostrar el resultado en la salida estándar.

La función OR en lenguaje ensamblador con sintaxis Intel es una operación lógica que se utiliza para realizar la operación OR (O inclusivo) entre dos operandos y establecer el resultado en un registro o una ubicación de memoria especificada.

section .data

msg1 db 'El resultado es ' 0x0A, 0x0D   

msg1Len equ $-msg1


section .bss
resultado resb 1 
resultadoLen equ $-resultado


section .text

global _start

_start:

mov al, 2
mov bl, 1

or al, bl

and al, 48
mov [resultado], al


mov eax, 4
mov ebx, 1
mov ecx, msg1
mov edx, Msg1Len
int 0x80

mov eax, 4
mov ebx, 1
mov ecx, resultado
mov edx, resultadoLen
int 0x80

mov eax, 1
mov eax, 0
int 0x80

El bloque a detallar es el siguiente:

mov al, 2
mov bl, 1

or al, bl

and al, 48
mov [resultado], al

or al, bl realiza una operación lógica OR entre los valores en los registros AL y BL. La operación OR establece el bit correspondiente en AL si cualquiera de los bits correspondientes en los registros AL o BL está establecido. De lo contrario, el bit en AL se establece en cero. En este caso, la operación OR resulta en que el bit menos significativo (LSB) de AL se establezca en 1.

La instrucción and al, 48 realiza una operación lógica AND entre el valor en el registro AL y el número 48 (que se representa en binario como 00110000). La operación AND establece el bit correspondiente en AL en 1 si ambos bits correspondientes en AL y 48 están establecidos. De lo contrario, el bit en AL se establece en cero. En este caso, la operación AND borra todos los bits excepto los 6 bits más significativos (MSB) de AL, lo que resulta en que AL contenga el valor 48.

El resultado se obtiene al realizar una operación OR entre los valores 2 y 1, lo que produce el valor 3 en binario (11 en binario). Luego, se aplica una operación AND con el valor 48 (en binario, 00110000), lo que resulta en el valor 48 (00110000 en binario). Este valor se almacena en la variable "resultado", y se muestra en la consola junto con el mensaje "El resultado es". Por lo tanto, la salida del programa sería:

El resultado es 3

Es importante tener en cuenta que la función "OR" no modifica ninguno de los operandos originales, sino que solo realiza la operación lógica y almacena el resultado en el destino especificado.

La operación lógica OR en ensamblador es una herramienta importante para manipular valores binarios. Se utiliza para realizar operaciones bit a bit entre dos valores, donde el resultado es 1 si al menos uno de los bits de entrada es 1.

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

En esta práctica se lleva a cabo un programa básico para determinar si un número es par o impar .

Usar los conocimientos de funciones booleanas y saltos para realizar un algoritmo y determinar si no numero es par

Nos apoyaremos de las operaciones lógicas en ensamblador 0 y 1. En esta ocasión, vamos a determinar si un número es par o impar. Esto imprimirá una cadena que define el resultado

section .data
    msg2 db "Es par", 10, 13
    lonmsg2 equ $-msg2
    msg3 db "Es impar", 10, 13
    lonmsg3 equ $-msg3

 section .text
    global _start

 _start:
  mov al, 7
  mov bl, 1

  and al, bl

  jz espar

    mov eax, 4
    mov ebx, 1
    mov ecx, msg3
    mov edx, lonmsg3
    int 0x80

    jmp salir

  espar:
    mov eax, 4
    mov ebx, 1
    mov ecx, msg2
    mov edx, lonmsg2
    int 0x80

  salir:
    mov eax, 1
    mov ebx, 0
    int 0x80

Primero, los valores de los registros "al" y "bl" se establecen en 7 y 1, respectivamente, utilizando las instrucciones "mov".

A continuación, el operador "and" se utiliza para realizar una operación lógica "and" entre "al" y "bl". El resultado se almacena en "al". Como 7 en binario es "111", y 1 en binario es "001", el resultado de la operación "and" es "001", que es 1 en decimal.

Después de la operación "and", el programa usa la instrucción "jz" para saltar a la etiqueta "espar" si la bandera de cero está establecida en el registro de banderas. Como el resultado de la operación "and" es 1, la bandera de cero no está establecida, por lo que el programa continúa ejecutando las instrucciones que siguen la etiqueta "jz".

El programa imprime el mensaje "Es impar" utilizando la llamada al sistema "write". Luego salta a la etiqueta "salir".

Si la bandera de cero se establece después de la operación "and", el programa salta a la etiqueta "espar". En este caso, el programa imprime el mensaje "Es par" y luego salta a la etiqueta "salir".

El código es bastante sencillo y utiliza pocas instrucciones. El uso de la operación "and" para verificar si un número es par o impar es una técnica común en programación de bajo nivel

El programa utiliza operaciones lógicas a nivel de bits para determinar si un número es par o impar. Esto demuestra cómo los programas en lenguaje ensamblador pueden ser altamente eficientes y controlar el hardware a un nivel muy detallado

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

En esta práctica se lleva a cabo un programa que hace una comparación entre dos números e imprime un resultado en la consola del sistema tratando de emular las estructura de control convencionales de lenguajes de alto nivel

Aprender y hacer uso de la estructura de control if/else por medio de un ejemplo practico

En este código, se ha utilizado la estructura de control if/else para tomar decisiones en función de una comparación entre el valor de un registro y una constante. Si el valor del registro eax es igual a 5, se ejecuta una serie de instrucciones que almacenan el valor 1 en la variable resultado. De lo contrario, se ejecutan otras instrucciones que almacenan el valor 0 en resultado.

Descripción paso a paso del desarrollo de la siguiente práctica:

section .data

section .bss
resultado resb 1

section .text

global _start

start:


mov eax, 5
mov ebx, 9

cmp eax, 5
jz funcionif
jmp else

funcionif:
    mov ebx, 1
    jmp salir

funcionelse:
    mov ebx, 0


salir:
    add ebx, 48
    mov [resultado], ebx


    mov eax, 4
    mov ebx, 1
    mov ecx, resultado
    mov edx, 1
    int 0x80

mov eax, 1
mov ebx, 0
int 0x80

if (eax == 5) {
    ebx = 1
}else {
    ebx = 0
}

En este código se implementa una estructura de control if/else utilizando las instrucciones cmp, jz y jmp.

Primero, se compara el contenido del registro eax con el valor 5 utilizando la instrucción cmp. Si son iguales, se ejecuta la etiqueta funcionif utilizando la instrucción jz. La instrucción jz salta a la etiqueta funcionif si la comparación anterior dio como resultado que los valores eran iguales.

Si la comparación en cmp no dio como resultado que los valores eran iguales, se salta a la etiqueta else utilizando la instrucción jmp. La instrucción jmp salta a la etiqueta else sin realizar ninguna comprobación adicional.

En la etiqueta funcionif, se carga el valor 1 en el registro ebx. Esto se ejecuta si la comparación en cmp dio como resultado que los valores eran iguales.

En la etiqueta funcionelse, se carga el valor 0 en el registro ebx. Esto se ejecuta si la comparación en cmp no dio como resultado que los valores eran iguales.

En este código se utiliza una estructura de control if/else para determinar qué valor se debe almacenar en la variable resultado según si el contenido del registro eax es igual o no a 5.

-- comparación
    cmp   registro1, registro2    -- compara el contenido de registro1 y registro2
    -- salto condicional
    je    etiqueta_if             --salta a etiqueta_if si los registros son iguales
    --código en caso de que no se cumpla la condición
    ...
    jmp   etiqueta_else           -- salta a etiqueta_else si no se cumple la condición
etiqueta_if:
    -- código en caso de que se cumpla la condición
    ...
    jmp   etiqueta_fin            -- salta a etiqueta_fin para evitar ejecutar código de else
etiqueta_else:
    -- código en caso de que no se cumpla la condición
    ...
etiqueta_fin:
    -- código después de if/else

La estructura if/else es una herramienta muy útil en programación, ya que permite tomar decisiones en función de ciertas condiciones o situaciones. En este caso, se ha utilizado para determinar si se debe almacenar el valor 1 o 0 en la variable resultado.

Es importante mencionar que el uso de la estructura if/else puede volverse más complejo en programas más grandes y con más variables y condiciones, por lo que es importante tener cuidado al diseñar la lógica de un programa utilizando esta estructura.

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

En esta práctica se crear un programa haciendo uso de un for para hacer operaciones aritméticas y mostrar el resultado en la consola.

Aprender y hacer uso de la estructura de control for por medio de un ejemplo practico

El programa utiliza instrucciones como mov, and, sub y add, así como llamadas al sistema, para realizar estas operaciones y al finalizar, obtener una suma de números impares (1 y 3).

Descripción paso a paso del desarrollo de la siguiente práctica:

section .bss
resultado resb 1

section .text
global start

_Start:
mov ecx, 3
mov eax, 0
mov ebx, ecx

for:
and ecx, ebx
jz suma
sub ebx, 2

suma:
add eax, ecx
loop for

add eax, 48
mov [resultado], eax

mov eax, 4
mov ebx, 1
mov ecx, resultado
mov edx, 1
int 0x80

mov eax, 1
mov ebx, 0
int 0x80

La primera instrucción "mov" establece el valor de "ecx" en 3, la segunda instrucción "mov" establece "eax" en 0 y la tercera instrucción "mov" establece "ebx" en el valor actual de "ecx", que es 3.

Después comienza un bucle "for" que realiza dos operaciones: "and" y "sub". La primera instrucción "and" realiza una operación lógica AND bit a bit entre "ecx" y "ebx" y almacena el resultado en "ecx". La segunda instrucción "sub" resta 2 de "ebx".

El bucle "for" se ejecuta mientras se cumpla la condición de que el resultado de la operación "and" sea igual a cero, lo que significa que no hay bits en común entre "ecx" y "ebx". Dentro del bucle, la instrucción "add" suma el valor actual de "ecx" a "eax" y la instrucción "loop" decrementa el registro "ecx" y salta de nuevo al comienzo del bucle "for" mientras "ecx" no sea cero.

Cuando se sale del bucle "for", se añade 48 a "eax" y se almacena el resultado en la variable "resultado".

El programa funciona correctamente y se obtiene la suma esperada

En la primera iteración del bucle, el valor inicial de "ecx" es 3 y el valor inicial de "ebx" es también 3. La operación "and" entre "ecx" y "ebx" devuelve el valor 3, que se almacena en "ecx". Como el resultado de la operación "and" no es cero, se ejecuta la operación "sub" que resta 2 a "ebx", lo que hace que "ebx" tenga un valor de 1.

En la segunda iteración del bucle, el valor actual de "ecx" es 3 y el valor actual de "ebx" es 1. La operación "and" entre "ecx" y "ebx" devuelve el valor 1, que se almacena en "ecx". Como el resultado de la operación "and" no es cero, se ejecuta la operación "sub" que resta 2 a "ebx", lo que hace que "ebx" tenga un valor de -1. …. y así sucesivamente.

El bucle "for" es controlado por la instrucción "loop" y utiliza la operación lógica "and" para realizar la operación matemática. Después de cada iteración, se verifica si el resultado de la operación lógica es cero y, en caso afirmativo, el bucle se detiene.

Finalmente, el resultado de la operación se almacena en una variable denominada "resultado" y se muestra en formato ASCII en la salida estándar utilizando la llamada al sistema "int 0x80" con el código de función adecuado.

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

Este es un código en lenguaje ensamblador que imprime dos mensajes de texto en la pantalla utilizando interrupciones del sistema. Su objetivo es mostrar cómo funcionan las interrupciones del sistema en este lenguaje y es útil para principiantes en el aprendizaje de lenguaje ensamblador.

El objetivo del código es mostrar cómo imprimir dos mensajes de texto en la pantalla utilizando interrupciones del sistema en lenguaje ensamblador x86

Este es un código escrito en lenguaje ensamblador x86 que utiliza la sintaxis de NASM. El objetivo del código es imprimir dos mensajes en la pantalla del usuario.

section .data
msg1 db "Mensaje 1", 10, 13
msg2 db "Mensaje 2", 10, 13

len1 equ $-msg1
len2 equ $-msg2

section .text

print:
mov eax, 4
mov eax, 1
int 0x80
ret ; regresamos a donde fue llamada al función

global _start
_start:

; no importa el orden de  los registros
mov ecx, msg1
mov edx, len1
call print


mov eax, 1
mov eax, 0
int 0x80

La función "print" es la encargada de imprimir una cadena de caracteres en la pantalla del usuario. A continuación se detallan las instrucciones que se ejecutan en esta función:

mov eax, 4 corresponde al código de la llamada al sistema que permite escribir en la salida estándar.

mov eax, 1 corresponde al descriptor de archivo estándar para la salida estándar.

int 0x80 - Se realiza la interrupción del sistema

ret - La función "print" devuelve el control a donde fue llamada utilizando la instrucción "ret".

En resumen, la función "print" utiliza dos instrucciones de movimiento de datos para cargar el código de la llamada al sistema y el descriptor de archivo en los registros "eax". A continuación, se realiza la interrupción del sistema con el número 0x80 para ejecutar la llamada al sistema correspondiente y escribir la cadena de caracteres en la salida estándar. Por último, la función devuelve el control a donde fue llamada utilizando la instrucción "ret".

El programa imprimirá el mensaje "Mensaje 1" en la pantalla del usuario, seguido de una nueva línea y un retorno de carro, y luego terminará. El segundo mensaje "Mensaje 2" no se imprimirá ya que no se llama a la función "print" con los parámetros correspondientes.

en general, la salida debería ser similar a la siguiente:

Mensaje 1

Los procedimientos en lenguaje ensamblador permiten agrupar un conjunto de instrucciones y parámetros en una sola función reutilizable y organizada.

Los parámetros se pasan a través de los registros o de la pila y los valores de retorno se almacenan en los registros específicos de retorno. Los procedimientos son una herramienta importante para modularizar el código y hacerlo más fácil de leer y mantener.

Este es un código en lenguaje ensamblador x86 que imprime dos mensajes de texto en la pantalla utilizando interrupciones del sistema. Su objetivo es mostrar cómo funcionan las interrupciones del sistema en este lenguaje y es útil para el aprendizaje de lenguaje ensamblador.

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm

El código utiliza la macro "imprime" para imprimir un mensaje en la pantalla y luego finaliza el programa.

El objetivo del programa es demostrar cómo se puede utilizar una macro para imprimir mensajes en la pantalla en el lenguaje ensamblador x86.

Este código es un programa de ensamblador x86 que define una macro llamada "imprime" que se encarga de imprimir mensajes en la pantalla y también define dos cadenas de caracteres en la sección de datos.

%macro imprime 2 
mov eax, 4
mov ebx, 1
mov ecx, %1 
mov edx, %2
int 0x80
%endmacro

section .data
msg1 db "Mensaje 1", 10, 13
msg2 db "Mensaje 2", 10, 13

len1 equ $-msg1
len2 equ $-msg2

section .bss

section .text

global _start
_start:

imprime msg1, len1


mov eax, 1
mov ebx, 0
int 0x80

Este código de ensamblador x86 muestra una implementación básica de una macro para imprimir mensajes en la pantalla utilizando llamadas al sistema de Linux. La macro "imprime" es definida con dos argumentos: el primer argumento representa la dirección de la cadena de caracteres que se desea imprimir, mientras que el segundo argumento indica la longitud de la cadena. La macro utiliza las instrucciones de ensamblador para cargar los valores correspondientes a los registros EAX, EBX, ECX y EDX antes de invocar la interrupción del sistema 0x80, que es la forma en que se realiza una llamada al sistema en Linux.

El programa define dos cadenas de caracteres en la sección de datos y utiliza la macro "imprime" para imprimir la cadena "Mensaje 1". A continuación, el programa utiliza las instrucciones de ensamblador para cargar los valores correspondientes a los registros EAX, EBX y la interrupción del sistema 0x80 para finalizar el programa.

La salida del programa será la impresión del mensaje "Mensaje 1" en la pantalla, seguido de la finalización del programa. Por lo tanto, en la salida del programa, solo se verá el mensaje "Mensaje 1" en la pantalla, y luego el programa finalizará sin imprimir nada más en la pantalla.

La macro "imprime" utiliza las llamadas al sistema de Linux para imprimir mensajes en la pantalla. El programa utiliza la macro para imprimir la cadena de caracteres "Mensaje 1" y luego finaliza el programa.

El código muestra cómo se puede utilizar una macro para imprimir mensajes en la pantalla en el lenguaje ensamblador x86 y también demuestra cómo se puede finalizar un programa en este lenguaje.

Assembly Programming Tutorial. (s. f.). https://www.tutorialspoint.com/assembly_programming/index.htm