\documentstyle{article}
\newcounter{nroejer}
\newcounter{nrosejer}
\title{
	Arquitectura de las Computadoras. \\
	Segunda plancha. \\
	{\it Assembler} de iAPX 386.
}
\date{}
\author{}
\begin{document}
\setcounter{nroejer}{0}
\setcounter{nrosejer}{0}
\newenvironment{ejercicio}
	{\addtocounter{nroejer}{1}\noindent{\bf\arabic{nroejer})}$\;\;$}
	{\vspace{.5cm}}
\newenvironment{sejercicio}
	{\addtocounter{nrosejer}{1}\noindent{\bf\roman{nrosejer})}$\;\;$}
	{\vspace{.3cm}}
\maketitle
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
{\bf Nota.} \\
\begin{itemize}
\item Los registros {\tt EAX}, {\tt EBX}, {\tt ECX}, {\tt EDX}
y sus subregistros {\bf no} son preservados en llamadas a funciones
de librer\'{\i}a ni en los servicios del n\'ucleo. Si son necesarios,
lo mejor es guardarlos en el {\it stack}.
\item Las instrucciones {\tt JCXZ}, {\tt JECXZ}, {\tt LOOP}, {\tt LOOPZ},
{\tt LOOPE}, {\tt LOOPNZ} y {\tt LOOPNE} s\'olo admiten desplazamientos
del 8 bits, y por eso no son usados por {\tt gcc}. {\tt Gas} puede generar
c\'odigo incorrecto --!`y en verdad lo hace!. Lo mejor es usar combinaciones
ortodoxas, como

\begin{verbatim}
                    decl %ecx
                    cmpl $0, %ecx
                    jnz nocero
\end{verbatim}
\end{itemize}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{ejercicio}
Las instrucciones {\tt ROL} y {\tt ROR} rotan los bits de su operando a
izquierda y derecha, dejando el bit izquierdo --respectivamente, el derecho--
en la bandera de acarreo ({\tt CARRY}) del registro de estado. Adem\'as existe
la instrucci\'on {\tt ADC}~{\it opo,~opd}
que calcula
{\tt opd}$\leftarrow${\it ops}$+${\it opd}$+${\tt CARRY}.
%%\centerline {{\tt opd}$\leftarrow${\it ops}$+${\it opd}$+${\tt CARRY}.}

Use esto para encontrar cu\'antos bits en uno tiene un entero ({\tt .long}) 
almacenado en memoria.
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
Implemente el algoritmo de ``fuerza bruta'' para buscar subcadenas 
--{\it substrings}-- usando {\tt CMPS}, {\tt SCAS}, {\tt REPE}, y
dem\'as de la familia.

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

\begin{verbatim}
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;
}
\end{verbatim}
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
En el programa que sigue, {\tt funcs} implementa
{\tt void (*funcs[])()=\{f1, f2, f3\}}, las l\'{\i}neas 20--23 
corresponden a {\tt scanf("\%d", \&entero)}. Compl\'etelo para
que la l\'{\i}nea 25 corresponda a {\tt funcs[entero]()}.
Use el c\'odigo m\'as eficiente.
\begin{verbatim}
 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
\end{verbatim}
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
Suponga un lenguaje que admite funciones anidadas, como Pascal.
Cada funci\'on activa tiene un marco de activaci\'on ({\it frame})
con sus variables locales. Encuentre c\'omo puede accederse desde
un {\it frame} activo de
profundidad de anidamiento $p_s$ a variables locales en otro {\it frame}
de profundidad $p_t$. Considere las situaciones cuando sea
$p_s< p_t$ y $p_s> p_t$.

\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
Implemente {\tt setjmp} y {\tt longjmp}. Ll\'amelas
{\tt setjmp2} y {\tt longjmp2}.
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
Rehaga en assembler el tercer ejercicio de la primera plancha.
Suponga el operando en {\tt AX} y use, a lo
m\'as, tres instrucciones.
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
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\~no, y 
generar c\'odigos de m\'aquina distintos (aunque equivalentes).

Sugerencia: para la longitud, ay\'udese con {\tt gdb}, que cuenta con
la orden {\tt disassemble}.
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\begin{ejercicio}
Implemente una funci\'on que reciba dos enteros en el {\it stack},
y  retorne 0 o 1 en {\tt EAX} seg\'un la suma de ambos provoque o
no desborde ({\tt overflow}). Haga dos versiones, una usando {\tt CARRY}
y otra no.
\end{ejercicio}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{ejercicio}
%\end{ejercicio}
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{ejercicio}
%\end{ejercicio}
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%\begin{ejercicio}
%\end{ejercicio}
%
\end{document}
