P1.- Para facilitar la tarea, suponemos definido en el segmento de datos lo siguiente:

Transcripción

1 Problemas P1.- Para facilitar la tarea, suponemos definido en el segmento de datos lo siguiente: ascii DB 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F 7_segm DB 3fh,06h,,71h el núcleo del código sería: mov dl, al lea bx, ascii xlat ascii equivalente a "mov al, [bx+al]" mov ch, al En lugar de una lista, podríamos haber hecho (teniendo en cuenta que los códigos ASCII son consecutivos para números y letras): mov dl, al cmp al,9 ja letra or al,30h el código ASCII de 0 es 30h mov ch,al jmp fin letra: sub al,10 lo que hay que sumar al código de 'A' add al,'a' el ensamblador sustituye 'A' por 41h. fin:... ahora 7 segmento: mov al,dl lea bx, 7segm xlat 7_segem mov cl, al mov al, dl P2.- Suponemos inicializados a su valor correcto CS y DS MAX EQU 128 se sustituye en tiempo de compilación NUM_ELEM DB 128 SUM DW? MED DW? VALORES DW MAX DUP? inicio: B_SUMA: LEA SI, VALORES MOV AX, 0 MOV CL, NUM_ELEM ADD AX, [SI] ADD SI, 2 DEC CL JNZ B_SUMA MOV SUM, AX CWD MOV BX, NUM_ELEM IDIV BX MOV MED, AX 1

2 En realidad, 128=2 7. Por tanto, la división podría haberse sustituido por: OTRA: MOV CL, 7 SAR DX,1 RCR AX,1 LOOP OTRA La mayoría de las veces esta secuencia es más rápida aunque suponga la ejecución de más instrucciones. P3.- El bucle C es: for (i=99 i>=0 i--) for (j=99 j>=0 j--) for (k=99 k>=0 k--) c[i][j]= a[i][k]+b[i][k] donde int i,j,k,a[100][100], c[100][100], c[100][100] mov word ptr DGROUP:_i,99 for (j=99j>=0j--) mov word ptr DGROUP:_j,99 for (k=99k>=0k--) mov word ptr DGROUP:_k,99 c[i][j]=a[i][k]+b[i][k] mov ax,word ptr DGROUP:_i mov dx,200 imul dx mov dx,word ptr DGROUP:_k shl dx,1 add ax,dx mov bx,ax mov ax,word ptr DGROUP:_a[bx] push ax mov ax,word ptr DGROUP:_i mov dx,200 imul dx mov dx,word ptr DGROUP:_k shl dx,1 add ax,dx mov bx,ax pop ax 2

3 add ax,word ptr DGROUP:_b[bx] push ax mov ax,word ptr DGROUP:_i mov dx,200 imul dx mov dx,word ptr DGROUP:_j shl dx,1 add ax,dx mov bx,ax pop ax mov word ptr DGROUP:_c[bx],ax dec word ptr DGROUP:_k cmp word ptr DGROUP:_k,0 jge short dec word ptr DGROUP:_j cmp word ptr DGROUP:_j,0 jge short dec word ptr DGROUP:_i cmp word ptr DGROUP:_i,0 jl jmp P4.- SI ceros DI pos neg otro: mov ax, word ptr SI] cmp ax, 0 je ceros jl neg inc word ptr [di + 2] jmp fin ceros:inc word ptr [di] jmp fin neg: inc word ptr [di + 4] fin: add si, 2 loop otro 3

4 P6.- MOV WORD PTR [DI],0 inicializo a la vez paridad [DI] y checksum [DI+1]. MOV CX,8 8 elementos OTRO: MOV AL,[SI] XOR [DI],AL ADD [DI+1],AL INC SI LOOP OTRO P7.-.MODEL small.data cadena db 'el helado eel ell'.stack Cadena ASCII, contar las veces de el main: mov ax,@data mov ds,ax mov si,offset cadena mov cx,0 contador de número de veces de 'el' otro: mov al,[si] cmp al,0 código de fin de cadena je fin cmp al,'e' jne otro cmp byte ptr [si],'l' jne otro inc cx jmp short otro fin: mov ah,4ch así se termina en MS-DOS int 21h END main P8.-.MODEL small.data cont dw? message db 81 db 81 dup (?) la que sea suponemos que el primer elemento es la longitud de la cadena.stack main: mov mov ds,ax mov dx, offset message inc dx mov si,dx mov cl,[si-1] mov ch,0 mov cont,cx ordena: mov bl,1 bandera que indica si ha habido cambios dec cont se hacen cont-1 comparaciones jz ordenado 4

5 mov cx,cont mov si,dx cada pasada se hace con 1 elemento menos (los mayores quedan abajo). sigue: mov al,[si] cmp al,[si+1] jbe no_cambio xchg [si+1],al mov [si],al xor bl,bl bl=0 si ha habido cambios no_cambio: loop sigue cmp bl,0 je ordena sólo si bl=1 es que no ha habido cambios (ordenada) ordenado: mov si,dx mov cl,[si-1] xor ch,ch add si,cx cseg mov ax,4c00h int 21h ends end main P9.- STRING SUBSTRING 0 mov bl, 0 mov cx, m mov ax, SEGMENT mov ds, ax mov es, ax mov di, STRING continua: mov si, SUBSTRING otro: mov al, [di] cmp al, 0 je fin inc di cmp al, [si] jne otro push cx 5

6 push di dec di cld repe cmpsb jne distintos jmp guarda_valores distintos: pop di pop cx jmp continua guarda_valores: mov ax, RESULT mov ds, ax mov si, DIRECT mov [si], SEGMENT mov [si + 2], DI fin: mov ax, RESULT mov ds, ax mov si, DIRECT mov word ptr [si], 0 alternativa: repe cmpsb jne distintos mov bl, 1 sí aparece jmp fin distintos: pop di pop cx jmp continua fin: mov ax, RESULT mov ds, ax mov si, DIRECT cmp bl, 1 je aparece mov word ptr [si], 0 jmp final aparece: mov [si], SEGMENT mov [si + 2], DI final: P10.-.MODEL SMALL.DATA cadena db race car0 temp db 20 dup?.stack main: mov mov ds, ax mov si, cadena 6

7 mov di, temp mov bl, 1 en principio es un palíndromo otro: mov al, [si] cmp al, 0 je fin cmp al, je otro mov [di], al inc di jmp otro fin: mov si, temp dec di compara las cadenas otro2: mov al, [si] cmp al, jne sigue jmp otro2 sigue: cmp [di],al jne no_pal dec di cmp si, di jb otro2 jmp si_pal no_pal: mov bl, 0 si_pal: mov ah, 4ch int 21h end main P12.- código C de prueba #include <stdio.h> extern unsigned long fact(unsigned int n) main() { long i i=fact(10) printf("%ld", i) }.MODEL small PUBLIC _fact _fact proc near push bp mov bp,sp mov cx, [bp+4] 7

8 cmp cx,0 je hecho dec cx push cx call _fact pop cx cmp ax,0ffffh jne sigue cmp dx,0ffffh je overfl sigue: inc cx push dx mul cx push dx push ax mov ax,[bp-2] mul cx jc overfl push ax mov ax, [bp-6] mov dx, [bp-4] add dx,[bp-8] jnc retorno overfl: mov ax,0ffffh mov dx,0ffffh jmp short retorno hecho: mov dx,0 mov ax,1 retorno: mov sp,bp pop bp ret _fact endp end P13. #include <stdio.h> extern void mult32(unsigned long k,unsigned long h, unsigned long *r) unsigned long k=8,h=2 unsigned long r[1] // define una cadena de 2 long (64 bits) para que quepa el resultado main() { mult32(k,h,&r) printf("%lx %lx", r[1], r[0]) // en hex., primero parte más significativa }.MODEL small PUBLIC _mult32 _mult32 proc near push bp mov bp,sp 8

9 mov mov mov mov cx,word ptr [bp+6] bx,word ptr [bp+4] dx,word ptr [bp+10] ax,word ptr [bp+8] mul bx ax*bx=dx:ax push dx p1h push ax p1l mov ax,word ptr [bp+10] mul bx dx*bx push dxp2h push axp2l mov ax,word ptr [bp+8] mul cx ax*cx push dxp3h push axp3l mov ax,word ptr [bp+10] mul cx dx*cx push dxp4h push axp4l sumar los productos parciales, [bp+10]:[bp+8] * [bp+6]:[bp+4] p1h:p1l p2h:p2l + p3h:p3l p4h:p4l mov bx, [bp+12] mov ax, [bp-4] mov [bx], ax mov ax, [bp-2] add ax, [bp-8] adc WORD PTR [bp-6],0 suma el carry. add ax,[bp-12] Esto no genera a su vez carry mov cx,[bp-6] adc cx,[bp-10] adc WORD PTR [bp-14],0 add cx, [bp-16] mov dx,[bp-14] adc dx,0 mov [bx+2],ax mov [bx+4],cx mov [bx+6],dx mov sp,bp pop bp ret _mult32 endp end P14. void funcion(long *vector, int longitud) Cambiar el signo a los elementos de vector 9

10 Se asume longitud > 0.MODEL small PUBLIC _funcion _funcion proc near push bp mov bp,sp mov cx,[bp+6] mov bx,[bp+4] otro: not WORD PTR [bx] complemento a 2 not WORD PTR [bx+2] add WORD PTR [bx],1 adc WORD PTR [bx+2],0 add bx,4 dec cx jne otro o bien "loop otro" fin: pop bp ret _funcion endp end Si el modelo fuera large:.model large PUBLIC _funcion _funcion proc far push bp mov bp,sp mov cx,[bp+10] les bx,[bp+6]es=segmento de vector bx=desplaz. de vector otro: not WORD PTR es:[bx] not WORD PTR es:[bx+2] add WORD PTR es:[bx],1 adc WORD PTR es:[bx+2],0 add bx,4 dec cx jne otro o bien "loop otro" fin: pop bp ret _funcion endp end si los números fueran en signo magnitud (como un float, 32 bits) otro: xor BYTE PTR [bx+3],80h cambia sólo el bit más significativo add bx,4 dec cx jne otro o bien "loop otro" 10