Escrever um programa em assembly (do cap. 9) que troque a posição dos seis bits MSB com os seis LSB de um número armazenado em uma dada posição na memória. O resultado deve ser armazenado em outra posição de memória. É OBRIGATÓRIO o uso de laço de repetição.

Passo 1

Beleza, vamos lá! O exercício pede para a gente escrever um programa em assembly que troca os seis bits mais significativos (MSB) com os seis bits menos significativos (LSB) de um número armazenado na memória. Depois, o resultado dessa troca deve ser guardado em outra posição de memória. Além disso, é obrigatório usar um laço de repetição no nosso código.
Para resolver isso, vamos precisar entender alguns conceitos básicos de manipulação de bits e como usar loops em assembly.

Passo 2

Primeiro, vamos entender o que são os bits mais significativos e os menos significativos. Em um número binário, os bits mais significativos (MSB) são os que ficam à esquerda e determinam o valor maior do número, enquanto os bits menos significativos (LSB) estão à direita e têm menor impacto no valor total.
No nosso caso, vamos trabalhar com 12 bits (6 MSB + 6 LSB).

Passo 3

Para trocar os bits, precisamos extrair os 6 MSB e os 6 LSB do número original. Vamos supor que o número esteja armazenado em uma posição de memória chamada NUMERO e que o resultado será armazenado em RESULTADO.

Passo 4

Vamos usar máscaras de bits para isolar os 6 MSB e os 6 LSB. Uma máscara é um número binário que usamos com operações AND para selecionar bits específicos.
  • Máscara para LSB: 000000111111 (em binário) ou 0x003F (em hexadecimal).
  • Máscara para MSB: 111111000000 (em binário) ou 0xFC0 (em hexadecimal).

Passo 5

Agora, vamos extrair os bits usando a operação AND:
AND NUMERO, 0x003F   ; Isola os 6 LSB
Para os MSB, primeiro precisamos deslocar os bits para a direita para alinhá-los:
SHR NUMERO, 6        ; Desloca 6 bits para a direita
AND NUMERO, 0x003F   ; Isola os 6 MSB agora na posição dos LSB

Passo 6

Depois de extrair os dois conjuntos de bits, vamos trocar as posições deles. Isso significa que os bits que eram MSB agora serão LSB e vice-versa.
Para fazer isso, precisamos deslocar os bits extraídos:
  • Deslocar os antigos LSB para a posição dos MSB:
    SHL LSB, 6        ; Desloca 6 bits para a esquerda
    
  • Os antigos MSB já estão alinhados como LSB após o deslocamento anterior.

Passo 7

Agora, vamos combinar os bits já na nova posição usando a operação OR:
OR MSB, LSB        ; Combina os bits trocados

Passo 8

Como o exercício exige o uso de um laço de repetição, vamos implementar um loop que processa cada bit individualmente. Esse loop vai iterar 6 vezes para os 6 bits que estamos trocando.

Resposta

Aqui está um exemplo de como o programa em assembly poderia ser estruturado para realizar a troca dos 6 MSB com os 6 LSB usando um laço de repetição:
section .data
    NUMERO      dw 0x3F3F        ; Número original armazenado na memória
    RESULTADO   dw 0x0000        ; Espaço para armazenar o resultado

section .bss

section .text
    global _start

_start:
    mov ax, [NUMERO]          ; Carrega o número original em AX
    mov bx, 6                 ; Inicializa o contador do loop com 6

    ; Inicializa registradores para armazenar MSB e LSB
    mov cx, 0                 ; CX irá armazenar os LSB
    mov dx, 0                 ; DX irá armazenar os MSB

troca_loop:
    shl ax, 1                 ; Desloca AX para a esquerda
    jnc sem_carry             ; Se não houve carry, pule para sem_carry
    or cx, 1                  ; Caso contrário, seta o bit correspondente em CX

sem_carry:
    shr ax, 1                 ; Desloca AX para a direita
    rcl dx, 1                 ; Rotaciona à esquerda o carry para DX
    dec bx                    ; Decrementa o contador
    jnz troca_loop            ; Repete o loop até que bx = 0

    ; Combina os novos MSB e LSB
    shl cx, 6                 ; Desloca LSB para a posição dos MSB
    or cx, dx                 ; Combina com os novos LSB

    mov [RESULTADO], cx       ; Armazena o resultado na memória

    ; Encerrar o programa (código para Linux)
    mov eax, 1                ; syscall: sys_exit
    int 0x80
Explicação do Código:
  1. Carregamento: O número original é carregado no registrador AX.
  2. Inicialização do Loop: BX é usado como contador para o loop, iniciando em 6.
  3. Loop de Troca:
    • Desloca AX para a esquerda para acessar os bits.
    • Verifica se houve um carry (overflow) e atualiza CX com os LSB.
    • Desloca AX para a direita e rotaciona os bits para atualizar DX com os MSB.
    • Decrementa o contador e repete até completar 6 iterações.
  4. Combinação dos Bits: Após o loop, os LSB e MSB são combinados na posição trocada.
  5. Armazenamento: O resultado é armazenado na posição de memória RESULTADO.
  6. Encerramento: O programa é finalizado.
Esse programa realiza a troca dos 6 bits mais significativos com os 6 bits menos significativos utilizando um laço de repetição, conforme solicitado no exercício.

Exercícios relacionados