Programación en Ensamblador con Visual Studio | | UPV
Summary
TLDREsta 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
💻 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.
🔧 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.
Mindmap
Keywords
💡Ensamblador
💡Visual Studio
💡Microprocesador Pentium
💡Longitud de palabra
💡Registros de propósito general
💡Instrucciones MOV
💡Instrucciones aritméticas
💡Instrucciones de control de flujo
💡Depuración
💡Breakpoint
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.
Browse More Related Video
SIMULADOR ASSEMBLER DE 8 BITS - SET DE INSTRUCCIONES DE 8 BITS - SIMPLE 8-BIT ASSEMBLY SIMULATOR
COMO CREAR un ALGORITMO para calcular el área de un triángulo y programar en PSeInt.
robot9
52. Programación en C++ || Ordenamientos || Ordenamiento por Selección
Curso Ensamblador 01(INTRODUCCION)
Aprende a programar desde cero con PseInt! | Primer Algoritmo! | Parte 4
5.0 / 5 (0 votes)