Estructura de Computadores. Examen 03.

Autor: Arturo Olivares Martos

---

• Asignatura: Estructura de Computadores.
• Curso Académico: 2023-24.
• Grado: Doble Grado en Ingeniería Informática y Matemáticas.
• Grupo: A.
• Profesor: Ignacio Rojas Ruiz.
• Fecha: 20-11-2023.
• Descripción: Repetición del examen de Temas 1 y 2 de Teoría, y prácticas 1-3.

El primer parcial se invalidó y se repetió por ser muy complicado y entrar materia que no habíamos dado.

Cada persona tenía un examen, por lo que hubo muchas versiones de este examen. De una batería de preguntas del profesor (salía de forma aleatoria); por lo que no hay un único examen, sino muchos. Esta es la primera versión subida.

Cada respuesta correcta suma 1 punto, y cada respuesta incorrecta resta 0.33 puntos. Las preguntas no respondidas no suman ni restan. La puntuación total es sobre 18.

---

1. Dado el siguiente fragmento de programa en ensamblador:
   xor %rbx,%rbx
xor %rcx,%rcx
sub $56,%rcx
mov $0x1,%ebx
rcr %cl,%rbx
   ¿Cuál es el valor del registro RBX al finalizar la última instrucción?

   • 0xFF
   • 0xFFFFFFFFFFFFFFFF
   • 0x0
   • 0x0300000000000000

2. Dado el siguiente fragmento de programa en ensamblador:
   xor %rbx,%rbx
xor %rax,%rax
sub $1, %rax
rcr $4,%rbx
   ¿Cuál es el valor del registro RBX al finalizar la última instrucción?

   • 0x0
   • 0x4
   • 0x1000000000000000
   • 0x40000000

3. Dado el siguiente fragmento de programa en ensamblador:
   mov $-18,%eax
sar $0x46,%eax
and $0xFF,%eax
   ¿Cuál es el valor del registro RAX al finalizar la última instrucción?

   • 0x0
   • 0xFFFFFFFF
   • Todo el resto de respuestas es incorrecto
   • 0xFF

4. Dado el siguiente fragmento de programa en ensamblador:
   mov $-18,%eax
sar $0x46,%eax
and $0xFF000000,%eax
   ¿Cuál es el valor del registro RAX al finalizar la última instrucción?

   • 0xFF000000
   • 0x00
   • 0xFF
   • Todo el resto de respuestas son incorrectas.

5. Dado el siguiente fragmento de programa en ensamblador:
   mov $-14,%eax
sar $3,%eax
and $0xFF,%eax
   ¿Cuál es el valor del registro RAX al finalizar la última instrucción?

   • 0xFFFFFFFF
   • 0x00
   • 0xFF
   • 0xFE

6. Dado el siguiente fragmento de programa en ensamblador:
   xor %rcx,%rcx
add $7,%rcx
mov $0x1234,%ebx
rcr %cl,%rbx
   ¿Cuál es el valor del registro RBX al finalizar la última instrucción?

   • 0xd000000000000024
   • 0x24
   • 0x0
   • 0x00000001234

7. ¿Cuál de las siguientes parejas de nemotécnicos de ensamblador corresponden a la misma instrucción máquina?

   • JC (saltar si acarreo), JL (saltar si menor, para números con signo).
   • CMP (comparar), SUB (restar).
   • JZ (saltar si cero), JE (saltar si igual).
   • SAR (desplazamiento aritmético a la derecha) / SHR (desplazamiento lógico a la derecha).

8. Suponga la siguiente sentencia asm en un programa:
   asm(" add (%[a],%[i],4),%[r]"
:[r] "+r" (result)
:[i] "r" (i),
[a] "r" (array)
);
   ¿Cuál de las siguientes afirmaciones es incorrecta?

   • Se desea que el valor calculado por la instrucción ensamblador quede almacenado en la variable result.
   • i es un registro de salida.
   • a es un registro de entrada.
   • r es un registro de entrada/salida.

9. ¿Cuál de las siguientes funciones en C NO puede traducirse al siguiente código en ensamblador?
   movslq %esi,%rsi
movq (%rdi,%rsi,8), %rax
ret
   

   • unsigned long elem (unsigned long v[], int i) {
return v[i];
}
   • unsigned *elem (unsigned *v[], int i) {
return v[i];
}
   • unsigned long *elem (unsigned long *v[], int i) {
return v[i];
}
   • unsigned long elem (unsigned long v[], int *i) {
return v[*i];
}

10. Dado el código de una función
    funcion: movq %rdi, %rax
movl $64, %ecx
shrq %cl, %rax
addq %rdi, %rax
ret
    este código:

    • Todas las respuestas son erroneas
    • Devuelve 0
    • Devuelve val.
    • Devuelve val * 2

11. Si en la práctica "media" se programa la suma de una lista de 16 enteros de 4B para producir un resultado de 8 B, primero sin signo y luego con signo, y la lista se rellena con el valor 0x0400 0000, ¿en qué se diferencian los resultados de ambos programas?

    • En uno ocupa 32 bits, en otro 64 bits.
    • En uno se interpreta como negativo, en otro como positivo.
    • En uno los 32 bits superiores son 0xFFFF FFFF, en el otro no.
    • No se diferencian.

12. Para crear espacio en la pila para variables locales sin inicializar suele realizarse la siguiente operación:

    • Sumar una cantidad positiva a RBP
    • Restar una cantidad positiva a RSP
    • Sumar una cantidad positiva a RSP
    • Restar una cantidad positiva a RBP.

13. En la secuencia de programa siguiente:
    628: e8 cd ff ff ff callq 5fa suma
62d: 48 83 c4 20 add $0x20,%rsp
    ¿cuál es el valor que introduce en la pila la instrucción callq?

    • 0x628
    • 0xffffffcd
    • 0x5fa
    • 0x62d

14. En x86-64, una función con 10 parámetros de tipo long que devuelve el valor del 8º parámetro y no modifica el puntero de pila puede traducirse a ensamblador como:

    • movq %r10, %rax
ret
    • movq %r8, %rax
ret
    • movq 8(%rsp), %rax
ret
    • movq 16(%rsp), %rax
ret

15. Respecto a la inicialización de los elementos del array:
    #define SIZE (1<<16)
for (i=0; i<SIZE; i++)
lista[i]=i;
    

    • popcount2 (bucle interno while) irá más lento con esta inicialización que con números aleatorios.
    • popcount1 irá (bucle interno for) irá más rápido con esta inicialización que con números aleatorios
    • Las tres funciones suma del programa suma_09_Casm irán igual de rápido con esta inicialización que con números aleatorios.
    • Cualquiera de las tres funciones suma del programa suma_09_Casm irá más rápido con esta inicialización que con números aleatorios.

16. La siguiente función calcula el factorial:
    fact:
pushq reg # preservar registro
movl %edi, %ebx
movl $1, %eax
testl %edi, %edi
je .L4
leal -1(%rbx), %edi
call fact
imull %ebx, %eax
.L4:
popq reg # restaurar registro
ret
    ¿Cuál es el registro <reg> que tiene que guardarse en la pila?

    • %rax
    • %rbx
    • %rsp
    • %rdi

17. Al traducir la sentencia C
    r->i = val;
    gcc genera el código ASM:
    movl %edx, 8(%rax)
    Se puede deducir que:

    • el desplazamiento de i en *r es 8
    • r es un puntero que apunta a la posición de memoria 8
    • val es un entero que vale 8
    • i es un entero que vale 8

18. Si el registro r12b contiene la variable booleana cond, y rax la variable valor, la secuencia de instrucciones:
    testb %r12b, %r12b
movq $13, %rax
cmove $17, %rax
    realiza la operación:

    • valor = cond ? 13 : 17;
    • valor = 17;
    • valor = cond ? 17 : 13;
    • valor = 13;