7.¶

z = 1 c = 0

¿Por qué esta operación pone cero el registro ah? Porque estamos comparando dos valores iguales, y la tabla or excluyente vuelve todo falso caundo los dos valores son iguales y, puesto que ah es igual a ah, vuelve falso el registro que se está comparando.

8.¶

c = 1

¿A qué se debe este valor? La bandera CF se levanta en operaciones de suma o mult. Ocurre porque el bit más significativo se desplaza fuera del registro o del operando y, por ende, se pierde. Este bit se coloca en la bandera de carry.

9.¶

AH = 01

¿Cómo tomó ese valor? Estamos ejecutando una suma con el carreo en el registro algo de ax y le estamos sumando 0 y, como la bandera del carry tenía 1 en su valor, por eso el nuevo valor es 01, ya que ah valía 0 por haber ejecutado el comando xor.

11.¶

cuenta = 04h dato = AAh

Dato en binario = 1010 1010 Cantidad de 1s en el dato binario = 4

¿Coincide con el valor de cuenta? Sí

12¶

cuenta = 05h dato = 5bh

Dato en binario = 0101 1011 Cantidad de 1s en el dato binario = 5

¿Coicide con el valor de cuenta? Sí

13¶

¿Cómo modificaría este programa para que en vez de contar el número de unos, cuente el número de ceros? Proponga 2 opciones alternativas.

Modificando el operador adc ah, 0 por adc ah, 1, asi haremos que la parte alta del registro ax se incremente en 1 si el bit más significativo del al es 0.


;**********************************************************
; CTABITS0.ASM
;
; Este programa cuenta el número de bits en cero de una
; variable de un byte. El pseudocódigo para este programa
; es:
;
; AL = dato
; AH = 0
;
; C = msb(AL) /* AL <<= 1 */
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
; C = msb(AL)
; AH += 1
;
; cuenta = AH
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
 ideal
 dosseg
model small
 stack 256
;****** VARIABLES DEL PROGRAMA ****************************
 dataseg
codsal db 0
dato db ?
cuenta db ?
;****** CÓDIGO DEL PROGRAMA *******************************
 codeseg
inicio:
 mov ax, @data ; Inicializa el
 mov ds, ax ; segmento de datos
 mov al, [dato] ; AL = dato
 xor ah, ah ; AH = 0
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 shl al, 1 ; C = msb(AL)
 adc ah, 1 ; AH += 1
 mov [cuenta], ah ; cuenta = AH
salir:
 mov ah, 04Ch
 mov al, [codsal]
 int 21h
;****** CÓDIGO DE TERMINACIÓN *****************************
 end inicio

Funciona de manera similar a la anterior, pero no sumaremos 1 al MSB, sino que le restaremos 1 al LSB del registro ax, es decir, al registro al


;**********************************************************
; CTABITS0_2.ASM
;
; Este programa cuenta el número de bits en cero de una
; variable de un byte. El pseudocódigo para este programa
; es:
;
; AL = dato
; AH = 0
;
; C = msb(AL) /* AL <<= 1 */
; AH += 1 - C
;
; cuenta = AH
;**********************************************************
;****** CÓDIGO DE INICIO **********************************
 ideal
 dosseg
model small
 stack 256

;****** VARIABLES DEL PROGRAMA ****************************
 dataseg
codsal db 0
dato db ?
cuenta db ?
;****** CÓDIGO DEL PROGRAMA *******************************
 codeseg
inicio:
 mov ax, @data ; Inicializa el
 mov ds, ax ; segmento de datos
 mov al, [dato] ; AL = dato
 xor ah, ah ; AH = 0
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 shl al, 1 ; C = msb(AL)
 adc ah, 1 - C ; AH += 1 - C
 mov [cuenta], ah ; cuenta = AH
salir:
 mov ah, 04Ch
 mov al, [codsal]
 int 21h
;****** CÓDIGO DE TERMINACIÓN *****************************
 end inicio

19¶

AH = 00AF

20¶

¿Cuál es el propósito de esta instrucción? El objetivo de esta instrucción es evaluar el resultado en ah no sea vacío.

21 y 22¶

¿Cuál es la finalidad de la primera de esas dos instrucciones? ¿Qué hace la segunda instrucción? ¿A qué operación de las necesarias para calcular el atributo de video substituye? (ver el comentario al inicio del programa)

mov cl, 4 ; AH <<= 4 
shl ah, cl

Resp. Pablo y Marro

La primera de las instrucciones clona el valor de 4 dentro de cl La segunda instrucción corre hacia la izquierda los bits de ah 4 veces.

Respuesta Daniel

La primera instrucción en el registro cl. Esto se usa para multiplicar el valor que hay en ah por 16.
La segunda instrucción desplaza los bits del registro ah a la izquierda en 4 posiciones
La segunda operacion substituye a la operación de multiplicar el color de fondo por 16 en el pseudocódigo. ¿por qué?

El comentario al inicio del programa indica que el atributo de video se calcula de la siguiente manera:

atrvid = ctexto + cfondo * 16 + blink

23¶

Ejecute las siguientes dos líneas:

mov al, [ctexto] ; AL = ctexto
and al, 0Fh; Al &= 0xF

¿Qué producen estas dos instrucciones?

Pone en 0 el valor de ctexto y activa las banderas z=1 y p=1 i=1 La descripción del proceso sería, que primero se carga el valor del color en el registro al, el valor del color de texto se almacena en la variable ctexto. y luego cambiamos el valor del registro al con el hexadecimal 15, esto para conservar solo los cuatro bits menos significativos en el registro al, que representan el valor del color del texto. Así que terminamos con el registro al con el color del texto.

24¶

Ejecute la siguiente línea: or ah, al ; ah |= al

¿Qué hace está instrucción? ¿A qué operación de las necesarias para calcular el atributo de video substituye? (ver el comentario al inicio del programa).

Combina el valor del color de texto con el valor del color de fondo. La instrucción realiza una suma entre el color, porque la operación OR equivale a una suma cuando los bits de los registros ah y al son iguales.
Sustituye la operación de suma

25¶

Ejecute las siguientes tres líneas:

mov al, [blink] ; al = blink 
ror al, 1 ; al = (al & 0x1) << 7 
and al, 80h

¿Que relación hay entre el valor que tiene el registro AL después de la última instrucción y el valor de la variable blink?.

Si el valor de la variable blink es 1, el valor del registro AL será 128. Si el valor de la variable blink es 0, el registro AL será 0.

La primera instrucción, mov al, [blink], guarda en la parte baja de ax el color del texto La segunda instrucción ror al, 1 desplaza los bits del registro al a la derecha 1 posición, esto tiene efecto de mover los LSB. Por último la última instrucción and al, 80h, conserva solo el bit más significativo del registro al. Por lo tanto, si el valor de blink es 1, el valor del bit más significativo será 1; la instrucción conservará este valor, lo que implica que el valor de al será 128. Si el valor de blink es 0, el valor del MSB será 0, y se conservará en al el valor de 0.