Arquitectura de las Computadoras.
Segunda plancha.
Assembler de iAPX 386.

Nota.

• Los registros EAX, EBX, ECX, EDX y sus subregistros no son preservados en llamadas a funciones de librería ni en los servicios del núcleo. Si son necesarios, lo mejor es guardarlos en el stack.
• Las instrucciones JCXZ, JECXZ, LOOP, LOOPZ, LOOPE, LOOPNZ y LOOPNE sólo admiten desplazamientos del 8 bits, y por eso no son usados por gcc. Gas puede generar código incorrecto -¡y en verdad lo hace!. Lo mejor es usar combinaciones ortodoxas, como

                      decl %ecx
                      cmpl $0, %ecx
                      jnz nocero
  

1)$\;\;$Las instrucciones ROL y ROR rotan los bits de su operando a izquierda y derecha, dejando el bit izquierdo -respectivamente, el derecho- en la bandera de acarreo (CARRY) del registro de estado. Además existe la instrucción ADC opo, opd que calcula opd$\leftarrow$ops$+$opd$+$CARRY.

Use esto para encontrar cuántos bits en uno tiene un entero (.long) almacenado en memoria.

2)$\;\;$Implemente el algoritmo de ``fuerza bruta'' para buscar subcadenas -substrings- usando CMPS, SCAS, REPE, y demás de la familia.

El algoritmo de ``fuerza bruta'', en C, es

int fuerzabruta(char *S, char *s, int lS, int ls)
{
    int i, j;
    for(i=0; i<lS-ls+1; i++)
        if(S[i]==s[0]) {
            for(j=0; j<ls && S[i+j]==s[j]; j++)
                ;
            if(j==ls) return i;
        }    
    return -1;
}

3)$\;\;$En el programa que sigue, funcs implementa void (*funcs[])()={f1, f2, f3}, las líneas 20-23 corresponden a scanf("%d", &entero). Complételo para que la línea 25 corresponda a funcs[entero](). Use el código más eficiente.

 1 .data
 2 fmt:
 3     .string "%d"
 4 entero:
 5     .long -100
 6 funcs:
 7     .long f1
 8     .long f2
 9     .long f3
10 .text
11 f1:
12     pushl $0; pushl $fmt; call printf; addl $8,%esp; jmp fin
13 f2:
14     pushl $1; pushl $fmt; call printf; addl $8,%esp; jmp fin
15 f3:
16     pushl $2; pushl $fmt; call printf; addl $8,%esp; jmp fin
17 .globl main
18 main:
19     pushl %ebp; movl %esp,%ebp
20     pushl $entero
21     pushl $fmt
22     call scanf
23     addl $8,%esp
24 ##  COMPLETAR!!!!!!!!!!!!
25     jmp *%edx
26 fin:
27     movl %ebp,%esp; popl %ebp; ret

4)$\;\;$Suponga un lenguaje que admite funciones anidadas, como Pascal. Cada función activa tiene un marco de activación (frame) con sus variables locales. Encuentre cómo puede accederse desde un frame activo de profundidad de anidamiento $p_s$ a variables locales en otro frame de profundidad $p_t$. Considere las situaciones cuando sea $p_s< p_t$ y $p_s> p_t$.

5)$\;\;$Implemente setjmp y longjmp. Llámelas setjmp2 y longjmp2.

6)$\;\;$Rehaga en assembler el tercer ejercicio de la primera plancha. Suponga el operando en AX y use, a lo más, tres instrucciones.

7)$\;\;$Encuentre, al menos, diez pares o ternas de grupos de instrucciones distintas pero que tengan el mismo resultado a partir de los mismos estados iniciales. Los pares o ternas deben tener igual tamaño, y generar códigos de máquina distintos (aunque equivalentes).

Sugerencia: para la longitud, ayúdese con gdb, que cuenta con la orden disassemble.

8)$\;\;$Implemente una función que reciba dos enteros en el stack, y retorne 0 o 1 en EAX según la suma de ambos provoque o no desborde (overflow). Haga dos versiones, una usando CARRY y otra no.