R-222 Arquitectura del Computador - LCC Examen Final - 9 de febrero de 2023 Examen condición libre Nombre y apellido: Legajo: IMPORTANTE: Justificar las respuestas e indicar de manera clara y detallada los procedimientos realizados para llegar a las soluciones. ## Ejercicio 1 (30 puntos) Dado el siguiente código en lenguaje C: ```c #include int a = 0x7fffffff, b = 1; int foo1(){ a=a+(b<<31); return a; } int foo2(){ a=a+b; return a; } int main(){ printf("0x%x 0x%x\n ", foo1(), foo2()); return 0; } ``` (a) Indicar lo que se imprime en pantalla al ser ejecutado. (b) Indicar el valor de las banderas CF y OF luego de realizarse cada una de las sumas. (c) Escribir un código equivalente en Assembler x86-64. (d) Dibujar un esquema que muestre la evolución de la pila. ## Ejercicio 2 (30 puntos) Dados dos arreglos de enteros de dimensión conocida declarados como variables globales: ```c int list1[5]={1, 2, 3, 4, 5}; int list2[5]={6, 7, 8, 9, 10}; ``` Escribir un programa en Assembler x86-64 tal que imprima por pantalla cada una de las componentes del arreglo que resulta de concatenar ambos arreglos. Es decir, con los valores de los arreglos mostrados debería imprimir 1 2 3 4 5 6 7 8 9 10. ## Ejercicio 3 (20 puntos) Dado el siguiente código en Lenguaje C: ```c #include struct empleado { char nombre[10]; char apellido[10]; short dia_ingreso, mes_ingreso, anio_ingreso, edad; float sueldo; }; struct empleado e1 = {"Juan", "Lopez", 9, 10, 2010, 45, 65536.0}; int main() { printf ("Nombre: %s\n Apellido: %s\n Sueldo: %f\n", e1.nombre, e1.apellido, e1.sueldo); return 0; } ``` (a) Dibujar el esquema de memoria, indicando los valores almacenados y las direcciones de memoria. Asumir que la estructura e1 está alojada en la dirección 0x404040. (b) Escribir un código equivalente en Assembler x86-64. ## Ejercicio 4 (10 puntos) Dado el siguiente programa en Lenguaje C: ```c #include int main(){ int a = 0x7fffffff, b = 0x1; printf("%x\n %x\n", a+b+(b<<31), a+b); return 0; } ``` (a) Indicar lo que sale impreso en pantalla al ejecutarse el programa. (b) Indicar si los resultados de las sumas son correctos. (c) Indicar si hubo acarreo. (d) Indicar si hubo desbordamiento. ## Ejercicio 5 (20 puntos) Dado el siguiente código en Assembler x86-64: ``` .global main main: 0x0000000000401102: movq $0x4000, %rdi 0x0000000000401109: movq $0x1122334455667788, %rsi 0x0000000000401113: pushq %rdi 0x0000000000401114: pushq %rsi 0x0000000000401115: call foo 0x000000000040111a: popq %rsi 0x000000000040111b: popq %rdi 0x000000000040111c: retq foo: 0x000000000040111d: pushq %rbp 0x000000000040111e: movq %rsp,%rbp 0x0000000000401121: movq 0x10(%rbp), %rax # <--- %rax=? 0x0000000000401124: movq 0x18(%rbp), %rdi # <--- %rdi=? 0x0000000000401127: movq %rbp,%rsp 0x000000000040112a: popq %rbp 0x000000000040112b: ret ``` (a) Escribir el contenido de la pila luego de ejecutarse el prólogo de la función foo, suponiendo como estado inicial rbp=0x7fffffffe088 y rsp=0x7fffffffe000. (b) Indicar el valor de los registros rax y rdi luego de ejecutarse las líneas correspondientes a sus comentarios. (c) Indicar el valor de retorno del programa. (d) Supongamos que hipotéticamente no tenemos disponible la instrucción call. Indicar un código Assembler alternativo para poder reemplazar a dicha instrucción en el código anterior. ## Ejercicio 6 (15 puntos) Dado el siguiente código en C que convierte de hectáreas a acres: ```c #include float hectareas_2_acres(float a){ return a*2.471; } int main(){ float a=7.0; printf("%f hectareas = %f acres\n", a, hectareas_2_acres(a)); return 0; } ``` Escribir un código equivalente en Assembler ARM para la función hectareas_2_acres. ## Ejercicio 7 (15 puntos) Dados los siguientes números en norma IEEE 754 simple precisión: - A=0x00780000 - B=0x00f80000 (a) Realizar el procedimiento para realizar la suma S = A + B en punto flotante simple precisión IEEE 754, mostrando el resultado en formato hexadecimal. (b) Indicar si el resultado es un número normalizado. (c) Indicar el menor número normalizado representable para esta forma de representación. (d) Convertir el resultado a doble precisión. ## Ejercicio 8 (30 puntos) Dado el siguiente código en C que realiza la suma elemento a elemento de dos arreglos de enteros: ```c #include int a[]={1, 2, 3, 4}; int b[]={5, 6, 7, 8}; int c[]={0, 0, 0, 0}; void suma(int a[], int b[], int L){ int i; for(i=0; i