Escrever um programa em assembly (do cap. 9) que desloque o conteúdo da posição 30 (hexa) da memória de duas posições à esquerda. Dois ZEROS devem ser colocados nas posições vagas mais à direita e o resultado deve ser armazenado na posição 31 (hexa). Se algum dos dois bits deslocados da posição 30 (hexa) for UM, deve-se zerar o conteúdo da posição 52 (hexa).

Passo 1

Beleza, vamos lá! O enunciado está pedindo para a gente escrever um programa em Assembly que faz algumas operações específicas na memória. O que precisamos fazer é:
  1. Deslocar o conteúdo da posição de memória 30 (em hexadecimal) duas posições para a esquerda.
  2. Colocar dois zeros nas posições que ficaram vagas à direita após o deslocamento.
  3. Guardar o resultado na posição de memória 31 (em hexadecimal).
  4. Verificar se algum dos dois bits que foram deslocados (saíram) da posição 30 era 1. Se sim, devemos zerar o conteúdo da posição 52 (em hexadecimal).
Para resolver isso, vamos precisar entender conceitos básicos de endereçamento de memória, operações de deslocamento de bits e condicionais em Assembly.

Passo 2

Primeiro, vamos carregar o conteúdo da posição de memória 30 para um registrador. Em Assembly, usamos registradores para manipular dados. Vamos supor que estamos usando o Registrador A.
LOAD A, 30h
Aqui, LOAD é a instrução para carregar o valor da posição de memória 30h no Registrador A.

Passo 3

Agora, vamos deslocar o conteúdo de A duas posições para a esquerda. O deslocamento para a esquerda multiplica o valor por 2 para cada posição deslocada. Como precisamos deslocar duas vezes, isso é equivalente a multiplicar por 4.
Em Assembly, usamos a instrução SHL (Shift Left) para isso.
SHL A, 2
Isso desloca o conteúdo de A duas posições para a esquerda.

Passo 4

Após o deslocamento, as posições vagas à direita precisam ser preenchidas com zeros. No caso do SHL, os bits que entram pela direita já são zeros, então não precisamos fazer nada adicional para isso.

Passo 5

Agora, vamos armazenar o resultado na posição de memória 31h.
STORE 31h, A
A instrução STORE guarda o conteúdo do Registrador A na posição de memória 31h.

Passo 6

Precisamos verificar se algum dos dois bits que foram deslocados da posição 30h era 1. Para isso, antes de fazer o deslocamento, vamos capturar esses bits.
Podemos criar uma máscara que capture os dois bits mais à esquerda. Supondo que estamos trabalhando com um registrador de 8 bits, a máscara seria 11000000 em binário, que é C0h em hexadecimal.
AND A, C0h
A instrução AND com a máscara C0h vai deixar apenas os dois bits mais à esquerda de A.

Passo 7

Depois, vamos comparar o resultado com zero. Se não for zero, significa que pelo menos um dos bits deslocados era 1.
CMP A, 00h
A instrução CMP compara o Registrador A com zero.

Passo 8

Se a comparação for verdadeira (ou seja, A não é igual a zero), vamos zerar o conteúdo da posição de memória 52h.
JNE Zera52
Aqui, JNE significa “Jump if Not Equal” (Pular se Não Igual). Se A não for zero, ele vai pular para a etiqueta Zera52.
Zera52:
    STORE 52h, 00h
Essa parte do código armazena zero na posição de memória 52h.

Resposta

Aqui está o programa completo em Assembly que realiza todas as operações solicitadas:
        LOAD    A, 30h        ; Carrega o valor da posição 30h para o Registrador A
        MOV     B, A          ; Move o valor de A para B para preservar os bits originais
        AND     B, C0h        ; Aplica a máscara para isolar os dois bits mais à esquerda
        CMP     B, 00h        ; Compara os bits isolados com zero
        SHL     A, 2           ; Desloca A duas posições para a esquerda
        STORE   31h, A        ; Armazena o resultado na posição 31h
        JNE     Zera52        ; Se os bits deslocados forem diferentes de zero, pula para Zera52
        JMP     Fim           ; Pula para o fim do programa
Zera52:
        STORE   52h, 00h      ; Zera o conteúdo da posição 52h
Fim:
        END                  ; Fim do programa
Explicação do Código:
  1. LOAD A, 30h: Carrega o valor de memória 30h no Registrador A.
  2. MOV B, A: Copia o valor de A para o Registrador B para não perder os bits originais.
  3. AND B, C0h: Isola os dois bits mais à esquerda utilizando uma máscara.
  4. CMP B, 00h: Compara os bits isolados com zero.
  5. SHL A, 2: Desloca o valor de A duas posições para a esquerda.
  6. STORE 31h, A: Armazena o resultado na memória 31h.
  7. JNE Zera52: Se os bits deslocados não forem zero, vai para a parte que zera a posição 52h.
  8. JMP Fim: Pula para o fim do programa se os bits deslocados forem zero.
  9. Zera52: Rótulo onde o programa zera a posição 52h.
  10. END: Indica o fim do programa.
Pronto! Agora você tem um programa em Assembly que realiza o deslocamento solicitado e trata a condição específica de zerar a posição 52h quando necessário.

Exercícios relacionados