Soluciones de los ejercicios sobre Algorítmez

Transcripción

1 Soluciones de los ejercicios sobre Algorítmez Siguiente: Soluciones de los ejercicios sobre Algorítmez (Periferia) Padre: Materiales didácticos Inicial: Fundamentos de ordenadores 1 a. entero: N = -( ) real: Normalmente (siempre que 0<C<255), N = ±1,M 2 C-127, pero aquí el campo C (de ocho bits) es C = 0, y M 0, y en este caso especial es N = ±0,M Por tanto: M = ,M = 0, = N = -( ) = -( ) b. [d] [d+1] [d+2] [d+3] c. Instrucciones de Algorítmez: [d] tipo 1; CO = H 0: SHR [d+1] (CR) = 9 [d+2] tipo 1; CO = H 8: IN [d+3] (CRX) = 8; (CR) = 0 Los dos primeros bytes son la instrucción SHR.9, y los dos siguientes, IN.0,[.8] 1

2 2 Definiendo estas máscaras: MSKEI EQU H 0100 MSKDI EQU H FEFF MSKCLRC EQU H F7 MSKCLRV EQU H FB EI y DI pueden realizarse así (utilizando R0 y una palabra, TMP, para almacenamiento temporal): EI ST.E, /TMP DI ST.E, /TMP LD.0, /TMP LD.0, /TMP OR.0, #MSKEI AND.0, #MSKDI ST.0, /TMP ST.0, /TMP LD.E, /TMP LD.E, /TMP Para CLRC y CLRV es similar, pero operamos sólo sobre el byte menos significativo (LD.E es una instrucción privilegiada): CLRC ST.B.E, /TMP CLRV ST.B.E, /TMP LD.B.0, /TMP LD.B.0, /TMP AND.0, #MSKCLRC AND.0, #MSKCLRV ST.B.0, /TMP ST.B.0, /TMP LD.B.E, /TMP LD.B.E, /TMP Para POP y PUSH, tenemos en cuenta que Algorítmez tiene el modo autoincremento (pero no autodecremento), y que PP = R14 puede actuar como otro cualquiera de los RPG: POP.5 : LD.5, [.14++] PUSH.5 : SUB.14, #2 ST.5, /0[.14] 3 a. b. Traducción: Resultado de la ejecución: LD.B.10,[.15++] 8B 12 -> R10 (8 bits menos signif.); FA (CP) + 1 -> CP DATA.B 12 0C Traducción: Resultado de la ejecución: LD.10,[.15++] 8A 12 -> R10 (16 bits); FA (CP) + 2 -> CP 2

3 DATA 12 0C 00 c. Traducción: Resultado de la ejecución: LD.10,[[.15++]] AA (MP[12]) -> R10 (16 bits); FA (CP) + 2 -> CP DATA 12 0C 00 Las instrucciones LD.B.10,#12, LD.10,#12 y LD.10,/12 se traducen exactamente igual que cada una de las tres parejas, y dan el mismo resultado. 4 Instrucción dir. bin. hex. comentarios LD.B.0,[.7++] [d] B autoincremento [d+1] RX=R7; R=R0; DE = (R7) LD.B.0,#2 [d] B autoincremento con RX=R15=CP [d+1] F0 RX=R15; R=R0; dir. op. = (CP) = d+2 [d+2] en un byte LD.B.0,/-10[.7] [d] B indexado [d+1] RX=R7; R=R0; DE = (R7)-10 [d+2] F6-10 en un byte LD.B.0,[[.7++]] [d] AB autoincremento indirecto [d+1] RX=R7; R=R0; DE = ((R7)) LD.B.0,/1000 [d] AB directo = autoincr. indirecto con RX=CP [d+1] F0 RX=R15; R=R0 [d+2] E8 H E8; extremista menor [d+3] H 03; D 1000 = H 3E8) Con relación a la tercera instrucción, cabe señalar que sería equivalente a LD.B.0,/65526[.7], ya que (R7)-10 = (R7) (módulo 2 16 = ). Sin embargo, ésta última no se podría codificar (sólo hay un byte para CD). 3

4 5 Soluciones de los ejercicios sobre Algorítmez ORG 1000 BR PRINC ; esta instruccion ocupa tres bytes DOS EQU 2 DATO DATA 2 PRINC LD.5, #DATO ; carga en R5... D 1003 (dirección de "DATO") [1009] LD.4, /DATO ; carga en R4... (1003) = [1013] LD.3, DATO ; carga en R3... (1003) = [1016] LD.2, #DOS ; carga en R [1020] LD.1, /DOS ; carga en R1... (2) (idéntica a LD.1, /2) [1024] Observaciones: Si un símbolo corresponde a la etiqueta de una EQU, el ensamblador le asigna el valor definido en esa EQU. En cualquier otro caso, le asigna el valor que corresponda a la dirección de esa etiqueta. En este caso, DOS tiene el valor «2», DATO «1003», y PRINC «1005». En la instrucción [1013], en ensamblador habrá puesto D -13 = H -D en el campo CD, de modo que cuando se ejecute, DE = (-13) = a. dir. contenido BR #-125 d C7 d+1 F0 d+2 83 d+3 FF ; D -125 = H FF83, en 16 bits con complemento a 2 b. Tras leer el segundo byte, (R15) = (CP) = d+2, y esto se introduce en CP. Por tanto interpreta el contenido de d+2 como el primer byte de una instrucción: Primer byte: H 83 = B : tipo 2, modo autoincremento, CO = ADDC.B Segundo byte: H FF: RX = 15; R = R15; esto hace que el modo sea inmediato, por lo que leería el operando, de un byte (por ser ADDC.B), que sería el contenido de d+4 y lo sumaría a los ocho bits menos significativos de R15 = CP, bifurcando así a una dirección que depende del contenido de d+4 y del valor del indicador C. 4

5 c. Si RX se incrementa antes de hacerse efectiva la bifurcación, es decir, antes de introducir su valor en CP, resulta que lo que se introduce en CP es d+4. Por tanto bifurca a la instrucción que está a partir de d+4, y el efecto es que BR #-125 es equivalente a NOP. (No obstante, obsérvese que este modo de calcular la dirección efectiva con direccionamiento inmediato no es correcto: basta analizar lo que ocurriría con LD.0, #-125). 7 a. Tablas y diccionarios: Tablas de símbolos Tablas de símbolos externos Tablas de símbolos de acceso Diccionarios de reubicación PRUEBA BINHEX REGHEX Símbolo Valor Símbolo Valor Símbolo Valor DP 0 MASC 15 RH_ENT 0 ENT 4 BH_ENT 0 BUCLE 5 SUM48 19 MEM 31 RH_ENT 14 BH_ENT 7 BH_ENT 0 RH_ENT 0 10, 14 7 b. Diccionario de reubicación resultante después del montaje: 10, 14, 24 c. Dirección (dec.) Contenido (hex.) Comentarios 1012 E6 Tipo 3, CO = 6, MD = autoincremento indirecto 1013 F0 RX = R15, para obtener el modo directo 1014 F9 (CD) = H 03F Explicación de CD: Al ensamblar PRUEBA, el ensamblador pone 0 en las direcciones 14 y 15, y RH_ENT = 14 en la tabla de símbolos externos. El montador pone 17 (comienzo de REGHEX) + 0 5

6 (valor de RH_ENT en la tabla de símbolos de acceso de REGHEX). El cargador reubicador le suma la constante de reubicación, 1.000, resultando así (CD) = D = H 03F9. 8 a. Rutina XOR: MODULE MXOR EXPORT XOR XOR LD.0, /0[.1] NOT.0 AND.0, /0[.2] ST.0, AUX ; (AUX) = NOT((R1)) AND ((R2)) LD.0, /0[.2] NOT.0 AND.0, /0[.1] OR.0, AUX ; (R0) = resultado final AUX RES 1 END b. Rutina CIFRA: MODULE CIFRAR FROM MXOR IMPORT XOR EXPORT CIFRA CIFRA PUSH.4 ; atención!: analizar bien el estado de la pila LD.4, /6[.14] ; (R4) = numero de palabras a codificar BZ FIN ; podria ser inicialmente 0 ; salvaguarda el contenido de los registros PUSH.1 ; que va a utilizar (R0 a R3) PUSH.2 PUSH.3 LD.1, /12[.14] ; (R1) = puntero a la palabra que guarda la clave LD.2, /18[.14] ; (R2) = puntero a la zona de datos originales LD.3, /16[.14] ; (R3) = puntero a la zona de datos codificados REPITE CALL XOR ST.0, [.3++] ADD.2, #2 ; avance del puntero R2 SUB.4, #1 ; comprueba si es fin de datos BNZ REPITE POP.3 ; recuperacion del contenido de los registros POP.2 ; utilizados (R0 a R3) POP.1 POP.0 FIN POP.4 ; recupera el registro R4 END 6

7 9 a. Para qué sirve la instrucción «ADD.14,#4»? Qué ocurre si se omite? Para recuperar el espacio ocupado en la pila por los parámetros que el programa le pasa al subprograma. Si se omite no pasa nada (sólo se pierden cuatro bytes de la pila) salvo si el programa ha sido llamado, a su vez, por otro programa. En tal caso fallaría el retorno a este último programa. b. Traducción a ensamblador de la función: /* Código C */ ; Código ensamblador /* */ ; int media(int a, int b) { MEDIA LD.0,/4[.14] return ((a+b)/2); ADD.0,/2[.14] SHR.0 } c. De X a CCC hay 22 bytes, por lo que la dirección de CCC es 32023, y la de SSS, 32027: Variables: tras CCC CALL /MEDIA tras SSS ADD.14,#4 X M?? Direcciones de MP: D D D Registro PP: a. Por qué la instrucción «LD.0, #M» tiene direccionamiento inmediato? Qué ocurriría si tuviese direccionamiento directo («LD.0, /M»)? Porque en el programa original en C no se pasa el valor de la variable m, sino su dirección. El 7

8 subprograma tiene que entregar el resultado en la palabra de dirección M, mediante direccionamiento indirecto. Si fuese «LD.0, /M», el resultado quedaría almacenado en la palabra cuya dirección es el contenido de M (probablemente, la palabra de dirección 0). b. Ahora salvaguardamos R0 para devolvérselo al programa como estaba: /* Código C */ ; Código ensamblador /* */ ; void media(int a, int b, int *pnt_m) { *pnt_m = ((a + b)/2); LD.0, /8[.14] ADD.0, /6[.14] SHR.0 ST.0, [/4[.14]] POP.0 } c. De X a CCC hay 28 bytes: Variables: tras CCC CALL /MEDIA tras SSS ADD.14,#6 X M? 10 Direcciones de MP: D (dir. ret.) D (dir. de M) D (X) 12 D (9) 9 Registro PP: /* Código C */ ; Código ensamblador /* */ ; main(int argc, char *argv[]) { int x2, x3; X2 RES 1 X3 RES 1 cuadcub(7, &x2, &x3); LD.0, #7 LD.0, #X2 LD.0, #X3 CALL /CUADCUB ADD.14, #6 8

9 } void cuadcub(int x, int *p2, int *p3) { CUADCUB PUSH.1 PUSH.2 LD.0, /12[.14] LD.1, /12[.14] CALL /MUL *p2 = x*x; ST.2, [/10[.14]] LD.0, [/10[.14]] CALL /MUL *p3 = (*p2)*x; ST.2, [/8[.14]] POP.2 POP.1 POP.0 } 12 a. Traducción: /* Código C */ ; Código ensamblador /* */ ; typedef struct snodo { ; Esto es una declaración, int valor; ; no genera ningún codigo struct snodo *sgte; } tnodo; ; Se crean y se inicializan ; los punteros: tnodo *cabz = NULL; CABZ DATA 0 tnodo *cola = NULL; COLA DATA 0 main(int argc, char *argv[]) { int i; I RES 1 MAIN LD.0, #0 for(i = 0; i < 100; i++) ST.0, I BUCLE CMP.0, #100 BNN SAL cola = encola(cola, i); LD.0, COLA LD.0, I CALL /ENCOLA ADD.14, #4 ST.0, COLA LD.0, I ADD.0, #1 9

10 } tnodo *encola(tnodo *pnodo,int dato) { tnodo *pnuevo; Soluciones de los ejercicios sobre Algorítmez SAL ST BR HALT.0, I BUCLE ; utiliza R0 para la variable ; local pnuevo ENCOLA PUSH.1 pnuevo = (tnodo*)malloc(4); LD.0, #4 CALL /MALLOC ADD.14, #2 if (pnodo==null) cabz = pnuevo; LD.1, /6[.14] BZ PRIMERO else pnodo->sgte = pnuevo; ADD.1, #2 ST.0, /0[.1] pnuevo->valor = dato; SIG LD.1, /4[.14] ST.1, /0[.0] pnuevo->sgte = NULL; LD.1, #0 ST.1, /2[.0] return pnuevo; POP.1 PRIMERO ST.0, CABZ BR SIG } b. Codificación de MALLOC: MALLOC ST.0, TEMP ADD.13, TEMP ST.13, TEMP CMP.14, TEMP BN ERROR SUB.0, TEMP NEG.0 ERROR CALL DESB_MEM TEMP RES 1 c. Si el programa es el codificado anteriormente (contando MAIN y ENCOLA, pero no MALLOC), ocupa 107 bytes, por lo que si se carga a partir de la dirección el último byte estará en la dirección Dir. (dec.) Contenido (hex.) 1106 (último byte del código) (primer dato) (D 1111 = H 457)

11 Dir. (dec.) Contenido (hex.) B F (segundo dato) (D 1115 = H 45B) (tercer dato) (D 1119 = H 45F) Siguiente: Soluciones de los ejercicios sobre Algorítmez (Periferia) Padre: Materiales didácticos Inicial: Fundamentos de ordenadores 11