Programación en Ensamblador con Visual Studio | | UPV

Summary

Esta presentación detalla cómo programar en ensamblador utilizando Visual Studio con un enfoque en el microprocesador Pentium. Se describe la evolución de la familia Pentium y se explican sus características clave, como la longitud de palabra de 32 bits y los registros generales. Seguidamente, se ilustra cómo escribir instrucciones en ensamblador, incluyendo transferencia de datos, aritmética, control de flujo y entrada/salida, dentro de un programa en C. Además, se muestra cómo depurar y ejecutar código paso a paso, utilizando breakpoints y visualizando registros y flags para comprender mejor el funcionamiento del código en ensamblador.

Takeaways

• 💻 Se presenta una introducción al uso del ensamblador en el entorno de desarrollo Visual Studio.
• 🛠 Se describe el microprocesador Pentium, utilizado en la mayoría de PCs y perteneciente a la familia de Intel de 80x86.
• 📊 El Pentium posee una longitud de palabra de 32 bits y cuatro registros de propósito general: EAX, EBX, ECX y EDX.
• ➡️ Las instrucciones en ensamblador incluyen transferencia de datos (mov), aritméticas (ADD, SUB, MUL, DIV) y control de flujo (JMP, JZ).
• 🔄 Se explica cómo programar en ensamblador dentro de un programa en C, lo que permite un control directo del procesador.
• 🎮 Se menciona la utilidad de programar en ensamblador para la optimización de código en aplicaciones como videojuegos.
• 🔧 Se detalla un ejemplo práctico de cómo se programa en ensamblador utilizando Visual Studio, incluyendo la ejecución paso a paso.
• 📖 Se visualiza el contenido de la memoria y los registros a través de la ventana 'Autos' y 'Registers' en Visual Studio.
• 🔴 Se introduce el concepto de 'breakpoint' para pausar la ejecución del programa en un punto específico del código.
• 🔁 Se demuestra un bucle en ensamblador que decrementa un registro hasta que alcanza cero, utilizando la ventana de registros para observar los cambios.

Q & A

¿Qué entorno de desarrollo se utiliza para programar en ensamblador en el guion proporcionado?

Se utiliza el entorno de desarrollo Visual Studio para programar en ensamblador.

¿Qué procesador se utiliza en la demostración del guion?

Se utiliza el procesador Pentium en la demostración.

¿Cuál es la familia de procesadores a la que pertenece el Pentium?

El Pentium pertenece a la familia de procesadores Intel de ochenta y ochenta y seis.

¿Cuál es la longitud de palabra del procesador Pentium?

La longitud de palabra del procesador Pentium es de treinta y dos bits.

¿Cuáles son los cuatro registros de propósito general principales del Pentium?

Los cuatro registros de propósito general principales del Pentium son EAX, EDX, ECX y EBX.

¿Qué instrucción se utiliza para transferir datos en ensamblador?

La instrucción 'mov' se utiliza para transferir datos en ensamblador.

¿Cómo se diferencian las instrucciones aritméticas de suma y resta en ensamblador?

Las instrucciones aritméticas de suma (ADD) y resta (SUB) permiten operar con cualquier registro o posición de memoria, pudiendo sumar o restar cualquier valor.

¿Cuál es la restricción al realizar multiplicación y división en ensamblador con el Pentium?

La multiplicación (MUL) y la división (DIV) solo se pueden realizar con el registro EAX, que es el registro acumulador.

¿Qué instrucciones de control de flujo se mencionan en el guion?

Se mencionan instrucciones de control de flujo como JMP para salto incondicional, JZ para saltar si el resultado es cero, y otras similares.

¿Cómo se puede integrar código en ensamblador dentro de un programa en C en Visual Studio?

Se puede integrar código en ensamblador dentro de un programa en C utilizando bloques de código entre las directivas #asm, permitiendo así el uso de instrucciones en ensamblador.

¿Qué herramienta se utiliza en Visual Studio para visualizar los registros de la CPU durante la depuración?

Se utiliza la ventana 'Registers' en Visual Studio para visualizar los registros de la CPU durante la depuración.

¿Qué es un breakpoint y para qué se usa en Visual Studio?

Un breakpoint es un punto en el código donde el programa se detendrá su ejecución automáticamente durante la depuración, permitiendo al programador inspeccionar el estado de la aplicación en ese momento.

Outlines

00:00

💻 Introducción al desarrollo de ensamblador con Visual Studio

El primer párrafo presenta una introducción al desarrollo en ensamblador utilizando Visual Studio. Se menciona que se utilizará el microprocesador Pentium, común en la mayoría de los PCs, y se describe brevemente la evolución de la familia Pentium desde el 8086 hasta el Core 2 Duo. Se destacan características del Pentium como su longitud de palabra de 32 bits y sus registros generales, y se explican las instrucciones básicas de ensamblador, como 'mov' para transferir datos, 'ADD' y 'SUB' para aritmética, y 'MUL' y 'DIV' para operaciones de multiplicación y división. También se mencionan instrucciones de control de flujo y entrada/salida. El párrafo concluye con una mención a cómo se puede programar en ensamblador dentro de un programa en C y la utilidad de esto para el control directo del procesador y la optimización del rendimiento.

05:04

🔧 Ejemplo práctico de programación en ensamblador con Visual Studio

El segundo párrafo se centra en un ejemplo práctico de cómo programar en ensamblador dentro de un programa en C utilizando Visual Studio. Se describe el proceso de ejecución paso a paso, incluyendo la visualización de variables y registros, y se explica cómo se utiliza el ensamblador para manipular directamente la memoria y los registros de la CPU. Se detallan las instrucciones de ensamblador utilizadas, como 'mov' para mover datos a un registro, 'sub' para realizar una resta, y 'JMP' para controlar el flujo del programa. Además, se menciona cómo se pueden utilizar breakpoints para pausar la ejecución del programa y analizar el estado de los registros en ese momento. El párrafo termina con una explicación de cómo se puede visualizar el registro de estado y los cambios en los registros durante la ejecución del programa.

Keywords

💡Ensamblador

El ensamblador es un lenguaje de programación de bajo nivel que se utiliza para escribir código que un compilador o un intérprete puede traducir en código máquina. En el guion, se menciona que se va a programar en ensamblador utilizando el entorno de desarrollo Visual Studio, lo que indica que el ensamblador es fundamental para el control directo del procesador y la optimización del código, como en el desarrollo de gráficos en videojuegos.

💡Visual Studio

Visual Studio es un entorno de desarrollo integrado (IDE) de Microsoft que permite desarrollar software para múltiples sistemas operativos y lenguajes de programación. En el guion, se utiliza Visual Studio para demostrar cómo programar en ensamblador dentro de un programa en C, destacando su capacidad para integrar diferentes lenguajes y proporcionar herramientas de depuración avanzadas.

💡Microprocesador Pentium

El microprocesador Pentium es una familia de procesadores de la compañía Intel, mencionada en el guion como el procesador que se utilizará en la demostración. Se describe cómo pertenece a la familia de Intel de 1986 y cómo ha evolucionado a través de diferentes versiones, siendo ampliamente utilizado en ordenadores personales, lo que resalta su relevancia histórica y actual en la computación.

💡Longitud de palabra

La longitud de palabra de un procesador, como la mencionada para el Pentium con treinta y dos bits, se refiere a la cantidad de bits que puede manejar en una operación. Esto直接影响a la cantidad de memoria y la precisión de los cálculos que el procesador puede gestionar, siendo un aspecto clave en la arquitectura de un procesador.

💡Registros de propósito general

Los registros de propósito general son componentes de la CPU que almacenan datos temporales durante la ejecución de un programa. En el guion, se mencionan registros como EAX, EBX, ECX y EDX, que son fundamentales para las operaciones aritméticas y de control de flujo en el ensamblador, permitiendo al programador un control preciso sobre la ejecución de instrucciones.

💡Instrucciones MOV

La instrucción MOV en ensamblador es utilizada para transferir datos de un lugar a otro, ya sea entre registros o entre un registro y una posición de memoria. En el guion, se ejemplifica cómo se utiliza para almacenar el contenido de una variable en un registro, mostrando su importancia en la manipulación de datos a nivel de hardware.

💡Instrucciones aritméticas

Las instrucciones aritméticas en ensamblador, como ADD y SUB, permiten realizar operaciones básicas de suma y resta. El guion destaca cómo estas operaciones pueden afectar a cualquier registro o posición de memoria, siendo fundamentales para el cálculo y el manejo de datos en un programa en ensamblador.

💡Instrucciones de control de flujo

Las instrucciones de control de flujo, como JMP y JZ, dictan cómo se ejecutan las instrucciones en un orden no lineal. En el guion, se muestra cómo estas instrucciones son esenciales para crear bucles y ramificaciones en el código, permitiendo al programador controlar el flujo de ejecución de manera efectiva.

💡Depuración

La depuración es el proceso de identificar y corregir errores en un programa. El guion menciona el uso de la depuración en Visual Studio para ejecutar paso a paso el código y observar el comportamiento de los registros y variables, lo que es crucial para comprender y solucionar problemas en programas escritos en ensamblador.

💡Breakpoint

Un breakpoint es un punto en el código donde el programa se detiene automáticamente durante la depuración. En el guion, se explica cómo establecer un breakpoint permite al programador observar el estado del programa antes de que se ejecute una instrucción específica, facilitando la comprensión y la solución de problemas en la ejecución del código.

Highlights

Introducción a la programación en ensamblador utilizando Visual Studio.

Descripción de las características del microprocesador Pentium.

Importancia del Pentium en la mayoría de los ordenadores personales.

Evolución de la familia de procesadores Pentium desde el 8086.

Compatibilidad de instrucciones entre diferentes versiones de Pentium.

Características técnicas del Pentium como longitud de palabra y registros generales.

Explicación de las instrucciones básicas en ensamblador: mov, add, sub, mul, div.

Diferenciación entre instrucciones de multiplicación/división y otras operaciones aritméticas.

Introducción a las instrucciones de control de flujo: JMP, JZ, etc.

Métodos de entrada/salida en ensamblador: in y out.

Ventajas de programar en ensamblador dentro de un programa en C para control directo del procesador.

Aplicaciones prácticas de ensamblador en el desarrollo de gráficos y videojuegos.

Procedimiento para programar en ensamblador dentro de Visual Studio.

Ejecución paso a paso de un programa en ensamblador utilizando la depuración en Visual Studio.

Uso de la ventana 'Autos' para observar cambios en variables durante la ejecución.

Transición de programación en C a ensamblador utilizando la directiva ASM.

Ejemplo de cómo se ejecutan las instrucciones en ensamblador paso a paso.

Importancia de manipular variables en lugar de direcciones de memoria directas.

Visualización de los registros y su significado en la ventana 'Registers'.

Uso de breakpoints para pausar y analizar el programa en un punto específico.

Conclusión de la presentación y agradecimientos.

Transcripts

Hola.

En esta presentación vamos a ver cómo podemos en ensamblador utilizando el entorno de desarrollo Visual /estudio/Studio/.

En primer lugar, vamos a describir brevemente /e// ciertas características del microprocesador Pentium, porque es el que vamos a utilizar en esta pequeña demostración.

¿Vale?

Es un procesador que lo podemos encontrar en la mayoría de ordenadores de tipo /pece/PC/, por lo tanto es el que seguramente tengáis en el ordenador de vuestra casa, y pertenece a la familia de Intel del ochenta ochenta y seis.

Esta familia empezó con el ochenta ochenta y seis, y luego le siguieron el dos ocho seis, tres ocho seis, cuatro ocho seis, diferentes versiones de Pentium, y hoy en día, pues ya se utilizan en un mismo chip /e// dos procesadores, como es el caso del core dos duo.

/e// Todos pertenecen a la misma familia, dado que tienen un conjunto de instrucciones que son compatibles con sus predecesores, de forma que todos los procesadores de esta familia todavía pueden ejecutar el código que hace más de treinta años se podía ejecutar en el ochenta ochenta y seis.

Bueno.

Como características más importantes, podemos decir que el Pentium tiene una longitud de palabra de treinta y dos bits, /SF//y que tiene cuatro registros de propósito general.

En concreto, van a ser el /a equis/AX/, /de equis/DX/, /SF// /e ce// /e// perdón, el /e a equis/EAX/, /e de equis/EDX/, /e ce equis/ECX/ y /e de equis/EDX/.

/e// /SF// /el// Sus instrucciones, aunque aquí sólo hemos mostrado las más importantes, pues son muy similares a las de cualquier lenguaje en ensamblador.

/ele/La/ instrucción más importante de transferencia de datos, es la instrucción mov, donde hay que indicar primero el destino y luego el origen.

Las instrucciones aritméticas tienen una peculiaridad y es que tanto la suma como la resta, /ad/ADD/ y /sub/SUB/, permiten operar con cualquier registro o posición de memoria, a la que podemos sumar o restar cualquier valor.

Pero la multiplicación y la división, /mul/MUL/ y /div/DIV/, solamente nos permite realizarlo con el registro /e a equis/EAX/, /SF// lo que es el registro acumulador.

Las instrucciones de control de flujo, pues son las típicas, /jota eme pe/JMP/ para el salto incondicional, tenemos /jota zeta/JZ/, saltar si cero, saltar si no cero, etcétera.

Y las típicas instrucciones de entrada salida, out e in.

Bueno.

En esta práctica vamos a ver cómo podemos programar en ensamblador del Pentium dentro de un programa en /ce/C/.

Esto nos lo permite realizar, pues, diferentes compiladores, /SF// y, aunque se utiliza con poca frecuencia, puede ser útil cuando queremos tener un control directo del procesador.

Por ejemplo cuando queremos optimizar al máximo el código que tenga la máxima velocidad, para, por ejemplo, el desarrollo de gráficos en videojuegos y ciertos aspectos muy particulares se suele utilizar.

Vamos a ver cómo se hace un ejemplo con Visual /beisic/Basic/.

Con, perdón, con Visual /estudio/Studio/.

/e// Este ejemplo /SF// que tenemos preparado está en la carpeta ejemplo, y lo vamos a arrancar, lo que es el fichero de solución, pinchando dos veces sobre él, /SF// y /e// tiene una única aplicación, la aplicación ejemplo, y un único fichero que es el main punto /cepepe/cpp/, y vemos como, pues, realmente es un programa en /ce/C/, empieza en /ce/C/, pero a mitad vamos a /e// realmente utilizar instrucciones en ensamblador.

Vamos a ir ejecutándolo paso a paso y vamos a ir describiéndolo.

Para ello vamos a pulsar con el botón derecho encima de la aplicación, /SF// seleccionamos debug, /SF// /estip into instans/step into instance/, /SF// y vemos como aparece una flecha amarilla que nos indica la siguiente instrucción a ejecutar.

Vamos a ir ejecutando paso a paso, utilizando el botón /estip over/step over/, /SF// y pues vemos como /e// va a irse mostrando, pues, /e// la primera instrucción, es una instrucción de /ce/C/ normal, que va a asignar un valor a la variable var.

Si volvemos /SF// a introducir, podemos, /e// si seleccionamos /la au// la ventana autos, vemos como la variable var acaba de tomar el valor dos mil.

Fijaros como la siguiente instrucción que vamos a ejecutar está dentro de un bloque que ha empezado con subrayado /a ese eme/ASM/.

Esto es la instrucción que nos permite /SF// pasar de programar en /ce/C/ a programar en ensamblador.

¿Vale? Esta llave se cierra aquí, y vemos que hemos introducido cuatro instrucciones en ensamblador: una de transferencia, una aritmética, una de control de flujo y una de salida.

Vamos a ir viendo estas cuatro instrucciones qué /qué// van a ir haciendo.

En primer lugar vamos a almacenar un mov dentro del registro /e ce equis/ECX/ /SF// lo que hay en una posición de memoria, al estar entre corchetes, pero /e// en este caso vamos a, en lugar de indicar una dirección de memoria, vamos a introducir el nombre de una variable.

¿Por qué?

Porque resultaría muy peligroso, /SF// y realmente no lo sabemos, manipular lo que es la memoria directamente sin conocer exactamente dónde está /el// las diferentes informaciones.

Lo que queremos acceder es a la posición de memoria donde está almacenada la variable var, y esto realmente sólo lo sabe el compilador.

Si introducimos su nombre, lo que va a hacer el compilador es sustituir el nombre de esta variable por la verdadera dirección de memoria donde está almacenada la variable var.

Por lo tanto, el efecto de esta instrucción es que en /SF// /e ce equis/ECX/ se va a almacenar el contenido de esta posición de memoria, /SF// que lógicamente es dos mil.

Vamos a ejecutar paso a paso y vamos a ver /SF// que esto es así.

Vemos como /SF// /e// /SF// /e ce equis/ECX/, que se visualiza aquí, acaba de tomar el valor dos mil, que es el que tenía la variable /SF// var.

Muy bien.

Vamos a seguir ejecutando paso a paso la siguiente instrucción.

Va a restar, sub, al registro /e ce equis/ECX/ uno.

Si ejecutamos, /SF// vamos a ver como /SF// pasa ahora a valer mil novecientos noventa y nueve.

La siguiente instrucción /SF// va a verificar si la última operación aritmética no ha sido cero y, en caso que no ocurra así, va a saltar a bucle, que está etiquetado en la instrucción anterior.

La instrucción anterior no ha dado cero, ha dado mil novecientos noventa y nueve y, por lo tanto, al no ser cero, saltará.

Al ejecutar el siguiente paso vemos que ha saltado.

Volvemos a restar uno.

/e// /SF// Todavía no ha sido cero, va a saltar.

Vemos como esto realmente va a ser un bucle que se va a repetir hasta que el registro /e ce equis/ECX/ llegue a cero.

Otro aspecto interesante que podemos visualizar /SF// es una ventana /SF// que encontramos dentro de debug /uindous/windows/, /SF// y es la ventana de registros, registers.

En esta ventana, nos va a mostrar los diferentes registros de la /cepeu/CPU/.

/e// /SF// Vemos los cuatro primeros hasta aquí, el /e a equis/EAX/, /e de equis/EBX/, /e ce equis/ECX/, /e de equis/EDX/.

¿Vale?

Los cuatro /e// de propósito general con sus diferentes valores.

Fijaros que está /e// mostrado en hexadecimal.

Como tenemos un total de ocho dígitos hexadecimales por cada registro, y cada dígito hexadecimal corresponde a cuatro bits, se trata de treinta y dos bits.

Bueno, aparte de estos registros, también conocemos el registro /e// /SF// de flags, o registro de estado, que también nos lo muestra en hexadecimal, /e// en el cual pues /e// hay diferentes bits que tienen un significado cada uno de forma individual.

Si queremos ver, de forma más clara, el significado de este registro, pinchamos con el botón derecho, seleccionamos flags y nos muestra cada uno de los bits del registro de indicadores, o registro de estado, qué valor tiene.

Vemos por ejemplo que el bit de cero todavía no se ha activado porque la última operación todavía no ha sido cero.

Si siguiéramos ejecutando paso a paso, /SF// vemos como /SF// en rojo se muestran los registros que acaban de cambiar, pero bueno, el registro de cero parece que /SF// /e// le va a costar bastante llegar a cero, de hecho tendríamos que repetir este bucle dos mil veces para conseguirlo.

Lógicamente no vamos a estar /SF// dándole dos mil veces /e// a estas dos instrucciones, /SF// y para solucionar este problema vamos a hacer lo siguiente.

Vamos a introducir un breakpoint en la siguiente instrucción a ejecutar.

Para hacer esto pinchamos /SF// en la parte izquierda /SF// del código, y vemos como aparece un punto rojo.

Esto nos va a indicar que hemos introducido aquí este breakpoint.

¿Para qué sirve?

Vamos a poder poner en marcha el programa /SF// dándole al botón de continuar, hasta que llegue a ese breakpoint, y ahí se va a parar.

Vamos a ver que esto es así.

Vemos como se ha ejecutado el programa de forma muy rápida, lógicamente, porque lo ejecuta el procesador, /SF// y vemos como el registro /e ce equis/ECX/, su valor actual es cero, y de hecho el bit de cero del registro de estado vale uno, está activado.

Es decir, la última operación aritmética que se ha realizado ha sido cero.

Lógicamente porque sino no hubiéramos continuado con la siguiente instrucción.

Bueno.

Y hasta aquí esta breve descripción de cómo podemos introducir /pro// un programa en ensamblador dentro del entorno Visual /estudio/Studio/.

Muchas gracias.