Parcial del 10/10/06 (Organización del Computador II)
De Cuba-Wiki
Ejercicio 1 (IA32)
Codigo ASM de las funciones Nota a tener en cuenta: tal vez si no hubiese usado las macros que recomendo Tute me hubiese salido todo mas facil...
; Definiciones para Windows %ifdef win32 %define SumaMiniI _SumaMiniI %define RestaNxDI _RestaNxDI %define malloc _malloc %endif ; Tal como le prometimos a C, aca estan las funciones global RestaNxDI global SumaMiniI ; El malloc lo tengo definido afuera extern malloc ; Comienzo del codigo section .text ;------------------------------------------------------------------- ; Macros que tute recomendo hacer ;------------------------------------------------------------------- ; Inicio del stack frame %macro SF_ini 0 push ebp mov ebp, esp push esi push edi push ebx %endmacro ; Fin del stack frame %macro SF_fin 0 pop ebx pop edi pop esi pop ebp ret %endmacro ; Lee un NGde de una posicion de memoria y asigna su tam a %1 y su r a %2 %macro LevantarNGde 3 %define reg_tam %1 %define reg_r %2 %define pNGde %3 mov dword reg_tam, [pNGde] mov dword reg_r, [pNGde + 4] %endmacro ; Levanta un NGde pero de tam solo 1, 2 o 4 apuntado por %2 y deja su correspondiente numero de 32 bits en reg_valor %macro LevantarNGdeMini 2 %define reg_valor %1 %define pNGde %2 ; Levanto el NGde... LevantarNGde eax, ecx, pNGde ; ...y me fijo como expandir el signo segun el tamaño con el que vino ;xor reg_valor, reg_valor cmp eax, 2 jl %%_uno je %%_dos %%_cuatro: mov reg_valor, [ecx] jmp %%_fin %%_dos: mov ax, [ecx] cwde mov reg_valor, eax jmp %%_fin %%_uno: mov al, [ecx] cbw cwde mov reg_valor, eax %%_fin: %endmacro ; Crea un nuevo NGde de tamaño %1. Deja a eax apuntandolo y en edi a r %macro NuevoNGde 1 %define tam %1 ; Pido para r push dword tam call malloc add esp, 4 mov edi, eax ; Pido para el NGde push dword 8 call malloc add esp, 4 ; Le informo cual es su tamaño y adonde tiene su numero (r) mov dword [eax], tam mov dword [eax + 4], edi %endmacro ;------------------------------------------------------------------- ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; NGde* SumaMiniI(Ngde *sumando1, NGde *sumando2) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SumaMiniI: ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; eax = ret ; ebx = sumando1 (alto) ; ecx = sumando2 (bajo) ; edx = sumando2 (alto) ; edi = ret->r ; esi = sumando1 (bajo) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SF_ini ; Cargo los 2 sumandos de parametro y extiendo los valores de 4 a 8 bytes. Si metiese de parametro a la macro [ebp + ...] terminaria haciendo ; doble indireccion en algun momento, asique mejor asi mov edx, [ebp + 8] LevantarNGdeMini eax, edx cdq mov esi, eax mov ebx, edx mov edx, [ebp + 12] LevantarNGdeMini eax, edx cdq mov ecx, eax ; Sumo la parte baja de los sumandos y la alta con carry, por si la suma de los bajos tiro un carry add esi, ecx adc ebx, edx ; Creo el NGde de retorno (siempre de tamaño 8) y guardo el puntero en ecx NuevoNGde 8 ; Agrego las dos mitades del resultado mov dword [edi + 4], esi mov dword [edi], ebx SF_fin ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; NGde* RestaNxDI(NGde *minuendo, NGde *sustraendo) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RestaNxDI: SF_ini mov ebx, [ebp + 8] ; ebx -> minuendo ; Creo el retorno con 4 bytes mas que el minuendo mov esi, [ebx] ; esi -> minuendo.tam add esi, 4 NuevoNGde esi ; eax -> ret, edi = ret.r push eax ; Guardo el valor de retorno asi ahora lo puedo pisotear felizmente mov ecx, [ebx] ; recupero el minuendo.tam en ecx ; Cargo el valor del sustraendo, total es de 4 bytes mov esi, [ebp + 12] ; esi -> sustraendo mov edx, [esi + 4] ; edx = sustraendo.r mov edx, [edx] ; edx = *(sustraendo.r) ; Le resto el sustraendo al dword menos significativo del minuendo y ya voy guardando en ret mov eax, [ebx + 4] ; eax -> minuendo.r mov esi, [eax + ecx - 4] ; esi = LSdword del minuendo.r sub esi, edx ; esi = la resta de los dwords mas bajos mov dword [edi + ecx], esi ; Guardo en el LSdword del ret.r, a este no le resto 4 porque tiene 4 bytes mas que el minuendo ; Ahora voy a ir recorriendo todos los dwords restando los burrows que se pudieron haber formado ; hasta que no tenga carry o me quede sin mas minuendo _bucle_burrow: dec ecx ; Hago esta chanchada para no alterar el carry dec ecx dec ecx dec ecx jz _fin_bucle_burrow ; Si no tengo mas tamaño a quien pedirle, termine. En algun momento va a ser 0 porque minuendo.tam mod 4 = 0 y voy restando de a 4 mov esi, [eax + ecx - 4] ; Cargo el dword del minuendo.r sbb esi, 0 ; Le resto solo el posible burrow (o carry) mov dword [edi + ecx], esi ; Escribo en el ret.r jmp _bucle_burrow _fin_bucle_burrow: ; Por ultimo, tengo que decidir si los 4 bytes de sobra que tiene el ret son extendidos de positivo o negativo. cmp dword esi, 0 jl _neg _pos: mov dword [edi], 0x00000000 jmp _sig _neg: mov dword [edi], 0xFFFFFFFF _sig: pop eax ; Recupero el puntero al ret que habia pisoteado felizmente SF_fin ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Codigo en C para probar las funciones
#include <stdio.h>
#include <stdlib.h>
/* Hice que la estructura sea un tipo asi mejoraba la sintaxis, en el fondo son lo mismo */
typedef struct{int tam; int *r;} NGde;
/* Le juramos a C que vamos a definirle estas funciones afuera */
extern NGde* SumaMiniI(NGde *sumando1, NGde *sumando2);
extern NGde* RestaNxDI(NGde *minuendo, NGde *sustraendo);
/* Muestra un NGde por pantalla */
void MostrarNGde(const NGde n)
{
/* Notar que como r es puntero a int hay que sumar solo 1 para avanzar un dword (sizeof(int) == 4) */
int i = 0;
while(i < n.tam)
{
printf("%p ", *(n.r + i / 4));
i = i + 4;
}
}
/************* Rutina de pruebas de la primer funcion *************/
void PruebasSumaMiniI()
{
/* Declaro 4 NGdes para usar de ejemplo y 3 punteros que van a apuntar a sus sumas */
NGde a;
NGde b;
NGde c;
NGde d;
NGde e;
NGde *s1;
NGde *s2;
NGde *s3;
/* Inicializo los 4 NGdes con algunos valores */
a.tam = 4;
a.r = malloc(a.tam);
*(a.r) = 0xFFFFFFFF;
printf("a.tam: %u, *(a.r): ", a.tam);
MostrarNGde(a);
printf("\n");
b.tam = 1;
b.r = malloc(b.tam);
*(b.r) = 0x0B;
printf("b.tam: %u, *(b.r): ", b.tam);
MostrarNGde(b);
printf("\n");
c.tam = 2;
c.r = malloc(c.tam);
*(c.r) = 0x4513;
printf("c.tam: %u, *(c.r): ", c.tam);
MostrarNGde(c);
printf("\n");
d.tam = 2;
d.r = malloc(d.tam);
*(d.r) = 0xE320;
printf("d.tam: %u, *(d.r): ", d.tam);
MostrarNGde(d);
printf("\n");
e.tam = 4;
e.r = malloc(e.tam);
*(e.r) = 0xFFFFFFFF;
printf("e.tam: %u, *(e.r): ", e.tam);
MostrarNGde(e);
printf("\n");
/* Tres sumas de ejemplo */
s1 = SumaMiniI(&a, &b);
printf("s1->tam: %u, *(s1->r): ", s1->tam);
MostrarNGde(*s1);
printf("\n");
s2 = SumaMiniI(&c, &d);
printf("s2->tam: %u, *(s2->r): ", s2->tam);
MostrarNGde(*s2);
printf("\n");
s3 = SumaMiniI(&e, &a);
printf("s3->tam: %u, *(s3->r): ", s3->tam);
MostrarNGde(*s3);
printf("\n");
/* Los leaks son mala onda */
free(s1->r); free(s2->r); free(s1); free(s2);
}
/************* Rutina de pruebas de la segunda funcion *************/
void PruebasRestaNxDI()
{
/* Declaro 4 NGdes para usar de ejemplo y 3 punteros que van a apuntar a sus restas */
NGde a;
NGde b;
NGde c;
NGde d;
NGde *r1;
NGde *r2;
NGde *r3;
/* Inicializo los 4 NGdes con algunos valores */
a.tam = 4;
a.r = malloc(a.tam);
*(a.r) = 0x00000100;
printf("a.tam: %u, *(a.r): ", a.tam);
MostrarNGde(a);
printf("\n");
b.tam = 4;
b.r = malloc(b.tam);
*(b.r) = 0x0000000A;
printf("b.tam: %u, *(b.r): ", b.tam);
MostrarNGde(b);
printf("\n");
c.tam = 12;
c.r = malloc(c.tam);
*(c.r) = 0xAE3490F1;
*(c.r + 1) = 0xAE3490F1;
*(c.r + 2) = 0xAE3490F1;
printf("c.tam: %u, *(c.r): ", c.tam);
MostrarNGde(c);
printf("\n");
d.tam = 32;
d.r = malloc(d.tam);
*(d.r) = 0;
*(d.r + 1) = 0;
*(d.r + 2) = 0;
*(d.r + 3) = 0;
*(d.r + 4) = 0;
*(d.r + 5) = 0;
*(d.r + 6) = 0;
*(d.r + 7) = 0;
printf("d.tam: %u, *(d.r): ", d.tam);
MostrarNGde(d);
printf("\n");
/* Tres restas de ejemplo */
r1 = RestaNxDI(&b, &a);
printf("r1->tam: %u, *(r1->r): ", r1->tam);
MostrarNGde(*r1);
printf("\n");
r2 = RestaNxDI(&c, &a);
printf("r2->tam: %u, *(r2->r): ", r2->tam);
MostrarNGde(*r2);
printf("\n");
r3 = RestaNxDI(&d, &a);
printf("r3->tam: %u, *(r3->r): ", r3->tam);
MostrarNGde(*r3);
printf("\n");
/* Los leaks son mala onda */
free(r1->r); free(r2->r); free(r3->r); free(r1); free(r2); free(r3);
}
/************* Punto de entrada ****************/
int main(int argc, char *argv[])
{
printf(" .................. Pruebas de SumaMiniI .................. \n");
PruebasSumaMiniI();
printf("\n\n .................. Pruebas de RestaNxDI .................. \n");
PruebasRestaNxDI();
return 0;
}
Makefile para compilar los dos archivos
RM= rm
NASM = nasm
# optimization
#
OPT= -g -ggdb -O2
# flags for ANSI compiles
#
CFLAGS= -pedantic -ansi -Wall ${OPT}
# ANSI compiler
#
GCC= gcc
OBJ=main.o parcial.o
OTHEROBJ=
INCS=
MAIN=parcial
.PHONY: all win linux
all:
@echo Debe elegir alguno de los sistemas operativos \(win, linux\). Ejemplo:
@echo make linux
win:
make NOPT="-fwin32 -Dwin32" ${MAIN}
linux:
make NOPT=-felf ${MAIN}
${MAIN}: ${OBJ} ${OTHEROBJ} $(INCS)
${GCC} ${CFLAGS} -o ${MAIN} ${OBJ} ${OTHEROBJ}
%.o: %.asm
${NASM} ${NOPT} -O1 $< -o $@
%.o: %.c
${GCC} ${CFLAGS} -c $< -o $@
clean:
${RM} -f ${OBJ} ${OTHEROBJ} ${MAIN}
install: all
${CAT} ${MAIN} > /dev/null
Notar que solo hay que poner "make win" o "make linux".
Ejercicio 2 (IA64)
a) signo
.proc signo signo: alloc loc0 = ar.pfs,1,1,0,0 cmp.eq p1,p2 = 0, in0 (p1) mov r8 = 0 (p2) cmp.gts.unc p3, p4 = 0, in0 (p3) mov r8 = -1 (p4) mov r8 = 1 mov ar.pfs = loc0 br.ret.sptk.many b0 .endp signo
b) Listas
.proc listas
listas:
alloc loc0 = ar.pfs,5,3,1,0
mov ar.lc = in4 // in4=N
mov loc1 = b0 //guarda el branch
loop:
ld8 loc2 = [in0], 8
mov out0 = loc2
br.call b0 = signo
cmp.eq p1,p2 = 0, r8
(p1) st8 [in3] = loc2, 8 // in3 = ceros
(p2) cmp.gts.unc p3, p4 = 0, r8
(p3) st8 [in2] = loc2, 8 // negativos
(p4) st8 [in1] = loc2, 8 // positivos
br.cloop loop
st8 [in1] = r0
st8 [in2] = r0
st8 [in3] = -1
mov b0 = loc1
mov ar.pfs = loc0
br.ret.sptk.many bo //termina la locura
Para Patricia esto estaba bien, espero que lo este para uds.
