CPU em Ação: O Processador Hipotético e os Fundamentos do Assembly

No artigo anterior — CPU — Componentes e Ciclo de Instrução — apresentamos os blocos que formam a CPU: UAL, UC, registradores, decodificador e clock. Descrevemos os microeventos do ciclo de busca em notação LTR e vimos como o CI, o REM e o RI cooperam para trazer uma instrução da memória. Mas descrevemos tudo em termos gerais. Agora vamos concreto: vamos acompanhar um processador hipotético executando instruções reais, bit a bit.

Usar um processador simplificado como modelo pedagógico é uma estratégia clássica na área: eliminamos a complexidade de arquiteturas comerciais (x86, ARM) e nos concentramos nos mecanismos fundamentais que qualquer processador real compartilha.

Neste artigo você vai entender:

• a organização do processador hipotético de 12 bits;
• o conjunto completo de instruções e sua notação em LTR;
• como codificar uma instrução em binário e hexadecimal;
• o fluxograma do ciclo de instrução completo;
• a execução passo a passo de LDA e ADD com tabelas de estado;
• os fundamentos da linguagem de montagem (assembly);
• programas assembly completos para problemas práticos.

O processador hipotético

#

Apesar de toda essa complexidade física dos chips modernos, os fundamentos lógicos que operam lá dentro permanecem surpreendentemente parecidos com os de seus ancestrais. Para entendermos como a CPU busca e executa instruções sem a “poluição” de bilhões de transistores e pipelines complexos, vamos dar um passo atrás. Usaremos como base um modelo de computador hipotético de apenas 12 bits.

O processador hipotético tem uma organização enxuta que mantém todos os componentes essenciais de um processador real. Sua especificação completa:

Perceba a coerência: o CI tem 8 bits porque 8 bits bastam para endereçar 256 células; o REM também tem 8 bits porque ele precisa transportar endereços; o RDM, o RI e o ACC têm 12 bits porque trabalham com palavras completas.

Formato das instruções

#

Cada instrução ocupa exatamente uma célula de memória — 12 bits divididos em dois campos:

• 4 bits de C.Op → \(2^4 = 16\) operações distintas possíveis
• 8 bits de operando → \(2^8 = 256\) endereços, cobrindo toda a memória

A figura abaixo mostra essa mesma divisão com uma instrução real preenchida — a 1B4, que aparece mais adiante no artigo. Vale reparar em duas coisas: cada dígito hexadecimal corresponde a exatamente quatro bits, e é por isso que o C.Op ocupa o primeiro dígito inteiro; e o operando, com seus oito bits, vai de 00 a FF, o limite que todo endereço deste processador precisa respeitar.

O número de operações possíveis e o espaço de endereçamento crescem exponencialmente com os bits disponíveis. Adicionar 1 bit ao C.Op dobra o número de instruções; adicionar 1 bit ao operando dobra o espaço de memória endereçável.

O conjunto de instruções

#

O conjunto de instruções do processador hipotético tem 15 entradas, cobrindo operações aritméticas, de movimentação de dados, desvios condicionais e incondicionais, e E/S:

O código F permanece livre para futuras extensões ou reservado.

Costumamos nos referir ao conjunto de instruções como ISA (Instruction Set Architecture). Ele define a interface entre o software e o hardware: quais operações o processador pode realizar e como elas são codificadas.

As instruções de desvio condicional (JZ, JP, JN) alteram o CI somente se a condição for verdadeira. Caso contrário, a execução continua normalmente — o CI já foi incrementado no ciclo de busca, portanto a próxima instrução sequencial é executada automaticamente.

Codificando instruções

#

Para codificar uma instrução em hexadecimal, basta concatenar os bits do C.Op com os bits do operando:

LDA 180\(_{10}\):

1. C.Op de LDA: \(1_{10} = 0001_2\)
2. Endereço do operando: \(180_{10} = 1011\ 0100_2 = \text{B4}_{16}\)
3. Instrução completa (12 bits): \(\underbrace{0001}_{\text{C.Op}} \underbrace{10110100}_{\text{operando}} = \mathbf{1\text{B}4}_{16}\)

ADD 181\(_{10}\):

1. C.Op de ADD: \(3_{10} = 0011_2\)
2. Endereço do operando: \(181_{10} = 1011\ 0101_2 = \text{B5}_{16}\)
3. Instrução completa: \(\underbrace{0011}_{\text{C.Op}} \underbrace{10110101}_{\text{operando}} = \mathbf{3\text{B}5}_{16}\)

O processo inverso — decodificar uma instrução hexadecimal — é igualmente direto: basta separar os 4 bits mais significativos (C.Op) dos 8 bits menos significativos (operando):

O ciclo de instrução completo

#

Com o conjunto de instruções definido, o fluxograma do ciclo de instrução fica completo. Ele opera indefinidamente até encontrar HLT:

flowchart TD
    START(["▶ INÍCIO"])

    subgraph BUSCA["Ciclo de Busca"]
        B1["REM ← CI
Envia endereço ao barramento"]
        B2["RDM ← M(REM)
Lê instrução da MP"]
        B3["RI ← RDM
CI ← CI + 1"]
    end

    subgraph EXEC["Ciclo de Execução"]
        E1{"Decodificar
C.Op de RI"}
        E2{"Precisa
buscar operando?"}
        E3["REM ← operando de RI
RDM ← M(REM)"]
        E4["Executar operação
(UAL ou UC)"]
    end

    HLT{"HLT?"}
    STOP(["⏹ PARAR"])

    START --> B1
    B1 --> B2
    B2 --> B3
    B3 --> E1
    E1 --> E2
    E2 -->|"Sim"| E3
    E3 --> E4
    E2 -->|"Não"| E4
    E4 --> HLT
    HLT -->|"Não"| B1
    HLT -->|"Sim"| STOP

Note que o CI é incrementado no ciclo de busca, antes da execução. Quando a instrução atual está sendo executada, o CI já aponta para a próxima. Isso é importante para as instruções de desvio: JMP e as variantes condicionais sobrescrevem o CI durante a execução, redirecionando o fluxo do programa.

Execução passo a passo — LDA

#

As duas tabelas a seguir acompanham LDA B4 e depois ADD B5 registrador por registrador, e isso exige manter cinco endereços na cabeça ao mesmo tempo. A figura abaixo serve de mapa para a leitura: ela mostra o trecho da memória que as duas execuções usam e o caminho de cada uma, em três passos numerados — o CI aponta a célula da instrução, o operando da instrução aponta a célula do dado, e o dado chega ao acumulador.

Vamos acompanhar a execução de LDA B4 — a instrução que a codificação anterior produziu, \(\text{1B4}_{16}\) — com o estado inicial: CI = 02; MP[02] = \(\text{1B4}_{16}\) (a instrução); MP[B4] = \(\text{1A7}_{16}\) (o dado a carregar).

Os passos 1–4 são o ciclo de busca (os mesmos \(t_0, t_1, t_2\) do artigo anterior). Os passos 5–9 são o ciclo de execução específico do LDA.

Execução passo a passo — ADD

#

Continuando a partir do estado deixado pelo LDA: CI = 03; MP[03] = \(\text{3B5}_{16}\); ACC = \(\text{1A7}_{16}\); MP[B5] = \(\text{07D}_{16}\).

Verificação: \(\text{1A7}_{16} = 423_{10}\); \(\text{07D}_{16} = 125_{10}\); \(423 + 125 = 548_{10} = \text{224}_{16}\) ✓

Executando desvios — JMP e JZ

#

Os desvios diferem de LDA e ADD em um aspecto importante: em vez de buscar um dado para a UAL processar, eles alteram o fluxo de execução por meio do Contador de Instrução.

JMP 09 (desvio incondicional):

1. Busca normal → RI recebe a instrução JMP; CI é incrementado.
2. Decodificação: UC identifica JMP → sinaliza salto incondicional.
3. \(\text{CI} \leftarrow 09\) — o operando vai direto para o CI, sem acesso à MP.
4. A próxima busca ocorre no endereço 09.

JZ 07 (desvio se ACC = 0):

1. Busca normal → RI = JZ 07; CI é incrementado.
2. Decodificação: UC identifica JZ → sinaliza salto condicional.
3. A UAL verifica se ACC = 0.
4. Se ACC = 0: \(\text{CI} \leftarrow 07\) → próxima execução no endereço 07.
5. Se ACC ≠ 0: CI permanece incrementado → próxima instrução sequencial.

A mesma lógica se aplica a JP (desvio se ACC > 0) e JN (desvio se ACC < 0): a condição é avaliada pela UAL usando as flags de estado, e o CI só é sobrescrito se a condição for verdadeira.

Da linguagem de máquina ao assembly

#

Programar diretamente em hexadecimal é trabalhoso e propenso a erros. A linguagem de montagem (assembly) resolve isso substituindo os códigos binários por mnemônicos alfanuméricos que mantêm uma relação direta com as instruções de máquina.

Estrutura de uma linha assembly

#

Rótulo      Operação    Operandos    ; Comentário
INICIO:     LDA         A            ; Carrega valor de A no ACC

O rótulo é opcional e identifica o endereço da instrução (útil para desvios). A operação é o mnemônico. O comentário é ignorado pelo montador.

Exemplo: \(X = A + B - C\)

#

Em alto nível, uma linha. Em assembly, quatro instruções — uma por operação primitiva da CPU:

LDA A    ; ACC ← (A)
ADD B    ; ACC ← ACC + (B)
SUB C    ; ACC ← ACC − (C)
STR X    ; (X) ← ACC

Cada linha corresponde exatamente a uma instrução de máquina. O compilador, ao processar a expressão de alto nível, gera uma sequência semelhante a essa.

Assembly na prática

#

A seguir, programas completos que ilustram o uso do conjunto de instruções do processador hipotético em problemas reais. Os endereços de memória são expressos em hexadecimal.

Verificação de senha com embaralhamento

#

Um sistema armazena a senha de forma embaralhada no endereço 42: o valor guardado é \(S/2 - (30)\), onde \((30)\) é o conteúdo do endereço 30. O usuário digita sua tentativa no endereço 20. O programa deve verificar se a tentativa confere e gravar 1 em 22 (acerto) ou 0 (erro).

Endereços auxiliares: 40 = 0, 41 = 1, 43 = 2.

; Estratégia: embaralhar o que o usuário digitou e comparar com o armazenado
00: LDA 20   ; ACC ← tentativa do usuário
01: DIV 43   ; ACC ← ACC / 2
02: SUB 30   ; ACC ← ACC − (30)  — agora ACC tem a tentativa embaralhada
03: SUB 42   ; ACC ← embaralhado calculado − embaralhado armazenado
04: JZ 08    ; Se ACC = 0 → senhas conferem; pula para 08
05: LDA 40   ; ACC ← 0
06: STR 22   ; (22) ← 0 — senha errada
07: HLT
08: LDA 41   ; ACC ← 1
09: STR 22   ; (22) ← 1 — senha correta
0A: HLT

Repare que todos os endereços têm dois dígitos hexadecimais, e isso não é estética: o operando tem 8 bits, então o maior endereço possível é FF. Um programa que citasse um endereço como 120 estaria fora da memória desta máquina.

O padrão SUB → JZ/JP/JN é a forma de implementar uma comparação no processador hipotético: subtrair os dois valores e verificar se o resultado é zero, positivo ou negativo.

00: GET 20   ; lê a tentativa do usuário direto para (20)
01: LDA 20   ; ACC ← tentativa
02: DIV 43   ; ACC ← ACC / 2
03: SUB 30   ; ACC ← tentativa embaralhada
04: SUB 42   ; compara com a senha embaralhada armazenada
05: JZ 0A    ; confere → pula para 0A
06: LDA 40   ; ACC ← 0
07: STR 22   ; (22) ← 0
08: PRT 22   ; mostra o resultado (0 = senha errada)
09: HLT
0A: LDA 41   ; ACC ← 1
0B: STR 22   ; (22) ← 1
0C: PRT 22   ; mostra o resultado (1 = senha correta)
0D: HLT

Folha de pagamento com teto salarial

#

Calcular o ganho total de um funcionário:

Dados: 15 = Ganho_Bruto, 16 = Bônus, 17 = Teto, 18 = Ganho_Adicional, 19 = Ganho_Total.

00: LDA 15   ; ACC ← Ganho_Bruto
01: ADD 16   ; ACC ← Bruto + Bônus
02: SUB 17   ; ACC ← (Bruto + Bônus) − Teto
03: JP 07    ; Se ACC > 0 (excedeu o teto) → pula para 07
04: LDA 15   ; Não excedeu: refaz Ganho_Bruto
05: ADD 16   ; ACC ← Bruto + Bônus
06: JMP 08   ; Pula para somar adicional
07: LDA 17   ; Excedeu: usa o Teto como base
08: ADD 18   ; ACC ← base + Ganho_Adicional
09: STR 19   ; Ganho_Total ← ACC
0A: HLT

Média de quatro sensores

#

Quatro leituras de sensores estão nos endereços 15, 16, 17 e 18. Calcular a média e armazenar em 13. O endereço 14 contém o valor 2.

; Divisão por 4 = dois DIVs por 2 consecutivos
00: LDA 15   ; ACC ← sensor1
01: ADD 16   ; ACC ← ACC + sensor2
02: ADD 17   ; ACC ← ACC + sensor3
03: ADD 18   ; ACC ← ACC + sensor4  (soma total)
04: DIV 14   ; ACC ← ACC / 2
05: DIV 14   ; ACC ← ACC / 2  (total: dividido por 4)
06: STR 13   ; média ← ACC
07: HLT

Neste processador, DIV é uma instrução explícita do repertório. Em uma CPU real, dividir por 4 também pode ser implementado por deslocamentos de bits, mas isso é um detalhe de implementação da UAL, não uma exigência do programa assembly. Dividir por 4 equivale a dois deslocamentos aritméticos de 1 bit à direita — o mesmo que >> 2 em linguagens de programação modernas.

Média e contagem de valores críticos

#

Três medições nos endereços 30, 31 e 32. (a) Calcular a média e armazenar em 40. (b) Contar quantas medições superam 50 e armazenar em 41.

Endereços auxiliares: 50 = 0, 51 = 1, 53 = 3, 55 = valor crítico 50.

; --- Parte A: Média ---
00: LDA 30   ; ACC ← med1
01: ADD 31   ; ACC ← ACC + med2
02: ADD 32   ; ACC ← ACC + med3
03: DIV 53   ; ACC ← ACC / 3
04: STR 40   ; média ← ACC

; --- Parte B: Contagem de valores > 50 ---
05: LDA 50   ; ACC ← 0 (inicializa contador)
06: STR 41   ; contador ← 0

; --- Testa med1 > 50 ---
07: LDA 30
08: SUB 55   ; ACC ← med1 − 50
09: JN 0E    ; se med1 < 50, não conta
0A: JZ 0E    ; se med1 = 50, também não conta
0B: LDA 41
0C: ADD 51
0D: STR 41

; --- Testa med2 > 50 ---
0E: LDA 31
0F: SUB 55
10: JN 15
11: JZ 15
12: LDA 41
13: ADD 51
14: STR 41

; --- Testa med3 > 50 ---
15: LDA 32
16: SUB 55
17: JN 1C
18: JZ 1C
19: LDA 41
1A: ADD 51
1B: STR 41

1C: HLT

O padrão correto para testar “maior que” com esse processador é:

1. subtrair o limiar;
2. descartar o caso negativo com JN;
3. descartar o caso igual com JZ;
4. só então incrementar o contador.

LDA 41   ; ACC ← contador
ADD 51   ; ACC ← contador + 1   — (51) guarda o número 1
STR 41   ; contador ← ACC

LDA 41   ; ACC ← contador
INC      ; ACC ← contador + 1
STR 41   ; contador ← ACC

Multiplicação por somas sucessivas

#

Os programas até aqui usaram ADD, SUB e DIV. Falta o caso clássico: como multiplicar quando não existe instrução de multiplicação? A resposta é um laço que soma o multiplicando tantas vezes quantas o multiplicador manda. Vale construí-lo, por dois motivos: é assim que a multiplicação existia antes de virar circuito, e é o primeiro programa deste artigo com estrutura de repetição de verdade.

Vamos calcular \((62) = (60) \times (61)\).

Endereços auxiliares: 63 = 0, 64 = 1, 65 = contador de trabalho.

; produto ← 0; repete (61) vezes: produto ← produto + (60)
00: LDA 63   ; ACC ← 0
01: STR 62   ; produto ← 0
02: LDA 61   ; ACC ← multiplicador
03: STR 65   ; contador ← multiplicador
04: LDA 65   ; ACC ← contador
05: JZ 0D    ; contador = 0 → acabou
06: LDA 62   ; ACC ← produto parcial
07: ADD 60   ; ACC ← produto + multiplicando
08: STR 62   ; produto ← ACC
09: LDA 65   ; ACC ← contador
0A: SUB 64   ; ACC ← contador − 1
0B: STR 65   ; contador ← ACC
0C: JMP 04   ; volta ao teste
0D: HLT

Acompanhando com \((60) = 3\) e \((61) = 2\): o contador entra valendo 2, o produto passa por 0, 3 e 6, o contador desce para 1 e depois para 0, e o JZ do endereço 04 encerra a execução com \((62) = 6\). São catorze instruções para uma multiplicação — e o tempo de execução cresce com o valor do multiplicador, não com o número de bits dele. Multiplicar por 1000 custa mil voltas no laço.

00: LDA 60   ; ACC ← multiplicando
01: MPY 61   ; ACC ← multiplicando × multiplicador
02: STR 62   ; produto ← ACC
03: HLT

O caminho inverso: STR (Store)

#

Enquanto as instruções LDA e ADD trazem dados da memória para a CPU, a instrução STR faz o exato oposto: salva o resultado do Acumulador de volta na Memória Principal. O fluxo de microeventos fecha o ciclo de comunicação:

1. (REM) <- (RI[endereço]): O endereço de destino (onde o dado será salvo) é copiado para o REM.
2. (RDM) <- (ACC): O dado já calculado sai do Acumulador e vai para o RDM (a “sala de espera” da saída).
3. (MP(REM)) <- (RDM): A Unidade de Controle emite o sinal de escrita pelo barramento de controle, e a memória grava o dado no endereço especificado fisicamente.

Esse fluxo fecha o ciclo completo de comunicação entre CPU e memória: buscar, processar e armazenar o resultado.

Por dentro da UAL: Como o silício calcula?

#

Até esse ponto, tratamos a operação ADD sem muitos detalhes. O decodificador manda um sinal e a UAL simplesmente “soma” os valores que chegaram da memória. Mas como um pedaço de silício consegue resolver matemática?

A resposta é que a UAL não entende números; ela entende eletricidade. Ela é construída por milhares de interruptores microscópicos organizados em circuitos chamados portas lógicas (como AND, OR, NOT e XOR). Cada porta recebe sinais elétricos (zeros e uns) e emite uma resposta baseada em uma regra lógica simples. Caso tenha um pouco de dificuldade, recomendo o artigo desta série sobre Álgebra Booleana.

Para realizar a soma de verdade quando a instrução ADD é executada, a CPU combina essas portas lógicas em blocos matemáticos:

• Meio Somador (Half-Adder): Um circuito simples que usa portas lógicas para somar dois bits individuais, gerando um resultado e um “vai-um” (carry). Seu defeito é não conseguir receber um “vai-um” de uma operação anterior.
• Somador Completo (Full-Adder): A evolução do circuito, capaz de somar três bits (os dois operandos mais o “vai-um” da coluna vizinha).

Ao enfileirar vários Somadores Completos lado a lado, a UAL consegue somar palavras inteiras de 12, 32 ou 64 bits em uma fração de nanossegundo, propagando o “vai-um” do bit menos significativo até o final. É assim que o comando abstrato do Assembly vira um fluxo elétrico real.

Deslocamentos de bits

#

Além de usar desvios para otimizar o fluxo do programa, a CPU também possui “atalhos” implementados diretamente no hardware para acelerar a matemática pesada. Em vez de acionar os somadores múltiplas vezes para fazer multiplicações ou divisões simples, a UAL inclui operações de deslocamento (shift). Elas são equivalentes a multiplicar ou dividir por potências de 2, mas executadas quase instantaneamente ao “empurrar” os bits para os lados:

Já abordamos isso anteriormente em um artigo sobre operadores bitwise, que explorou as operações bit a bit. Vamos ver um exemplo prático para fixar a ideia.

Para \(5_{10} = 0101_2\):

O exemplo da média de sensores (dividir a soma por 4 com dois DIV 14 onde (14) = 2) é exatamente dois shifts right consecutivos.

O Rastreamento de Execução (Tracer)

#

Para visualizar o comportamento da CPU ao longo do tempo, é útil montar uma tabela de rastreamento que registre o estado dos principais registradores a cada fase de busca e execução.

A tabela abaixo é uma construção didática, inspirada no funcionamento do processador hipotético, para acompanhar a sequência LDA 20, ADD 21, STR 22 assumindo MP[20] = 5 e MP[21] = 3:

Esse tipo de tabela funciona como um “raio-x” do ciclo de instrução.

Observe o fluxo perfeito: no passo 6, o valor 8, que estava no Acumulador, foi jogado para o RDM para ser fisicamente gravado no endereço 22 da memória. A CPU funciona no ritmo do relógio.

Conclusão e próximos artigos

#

O processador hipotético condensa os mecanismos essenciais de qualquer processador real: um repertório de instruções codificado em bits, um ciclo que busca e executa cada instrução em sequência, e desvios que alteram esse fluxo com base em condições. O assembly revela a correspondência direta entre essas instruções e o código que o hardware executa.

No próximo artigo, vamos avançar para a execução paralela de múltiplas instruções com a técnica de pipeline. Veremos como isso multiplica o desempenho, quais hazards podem interromper esse fluxo e como a unidade de controle coordena tudo para manter a execução fluida.

Até lá!