REPRESENTAÇÃO DE INSTRUÇÕES

ENDEREÇAMENTO DE INSTRUÇÕES

Até agora, vimos considerando que o operando contém o endereço da MP onde está localizado o dado, mas esta não é a única forma. Existem outros modos de endereçamento de forma a ampliar a flexibilidade para o programador.

O endereço da próxima instrução é apontado através do valor armazenado no CI. A ação a ser realizada pela instrução é determinada pelo mnemônico da instrução, armazenado no campo “CÓDIGO DE OPERAÇÃO” (ou abreviadamente opcode).

O dado da instrução pode ser um valor numérico, um caractere ou mesmo um endereço (no caso das instruções de desvio). A localização do dado é em geral explicitamente indicada na própria instrução, sendo representada no campo (ou campos) “OPERANDO” (ou abreviadamente Oper).

Nota: Os exemplos a seguir apresentados se baseiam, sempre que possível, no microprocessador Intel 8080. O Intel 8080 possui palavra e células de memória de 8 bits, e suas instruções são de 1 operando (com o acumulador como operando implícito) e podem ocupar 1, 2 ou 3 bytes na memória.

FORMATO GERAL DA INSTRUÇÃO NO INTEL 8080
PALAVRA DE DADOS

INSTRUÇÕES DE 1 BYTE

INSTRUÇÕES DE 2 BYTES

INSTRUÇÕES DE 3 BYTES

EXEMPLO DE INSTRUÇÕES NO INTEL 8080
Exemplo de Instrução de 1 byte:
ADD r (add register) ==> (ACC) <--- (ACC) + (r)
(o conteúdo do registrador indicado em SSS é somado ao conteúdo do acumulador e o resultado é colocado no acumulador).

onde SSS representa o registrador de origem (source register), conforme tabela abaixo.

INDICAÇÃO DO REGISTRADOR ENVOLVIDO EM UMA OPERAÇÃO

Exemplo de Instrução de 2 bytes:
ADI data (add immediate) ==> (ACC) <--- (ACC) + (byte2)
(o conteúdo do 2º byte da instrução é somado ao conteúdo do acumulador e o resultado é colocado no acumulador.

Exemplo de Instrução de 3 bytes:
Jcondition addr (conditional jump) ==> if CCC, (PC) <--- (byte 2) (byte3)

onde CCC representa o código de condição dos indicadores de condição (flags), conforme tabela abaixo.

MODOS DE ENDEREÇAMENTO
MODO IMPLÍCITO (Implied Addressing)
A função da instrução traz implícito o endereçamento.

Exemplo
No microprocessador Intel 8080 essas instruções ocupam apenas 1 byte; são as seguintes as instruções com endereçamento implícito:
STC (set carry flag) - "seta" o bit de carry e CMC (complement carry) - complementa o valor do bit de carry; - o operando implícito é o carry flag.
RAL (rotate accumulator left), RAR (rotate accumulator right) - instruções de deslocamento de bits, à esquerda e à direita - o operando implícito é o acumulador;
RLC (rotate accumulator left through carry) e RRC (rotate accumulator right through carry) - instruções de deslocamento de bits, à esquerda e à direita, através do carry flag - os operandos implícitos são o acumulador e o carry flag;
DAA (decimal adjust accumulator) - instrução para aritmética em BCD - o operando implícito é o acumulador.

MODO IMEDIATO
O valor do campo operando é o próprio dado.

É usado para trabalhar com valores constantes. O operando é dito operando imediato (o operando é o próprio valor a ser operado, ou seja, é o próprio dado a ser processado).

Vantagem
O operando é obtido durante o ciclo de busca, em apenas 1 acesso. Não é necessário fazer nenhum acesso à MP no ciclo de execução, acarretando maior rapidez na execução.

Desvantagens
a) O tamanho do dado fica limitado ao número de bits do operando (campo operando da instrução). A limitação de tamanho do campo operando reduz o valor máximo do dado que pode ser armazenado. No Intel 8080, o campo Operando tem 8 bits, portanto o maior valor deste campo será limitado a 2⁸ = 256. Existem instruções que permitem carregar doublewords, isto é, palavras duplas que ocupam 2 células de memória, em que o maior valor será limitado a 2¹⁶ = 65.536 (64 k).
b) Este modo de endereçamento não permite flexibilidade para alterar dados que variam a cada execução do programa, portanto não é adequado para variáveis repetidamente operadas com diferentes valores a cada execução do programa.

Utilização
- Inicialização de contadores
- Constantes
- Armazenamento de ponteiros em registradores
- Indicação de quantidade de posições em operações de deslocamento de bits (multiplicação e divisão)

Exemplos
Exemplos
Obs.: Instruções do Intel 8080.
LDI Op ==> ACC <--- Op = carrega o valor (hexadecimal) do operando no acumulador.
LDI 50 (load immediate) ==> ACC <---- 50 (carrega o valor hexadecimal 50 no acumulador)

LDI 'Op' ==> ACC <--- 'Op' = carrega o caractere representado no operando no acumulador.
LDI 'C' (load immediate) ==> ACC <---- C (carrega o caractere C (ASCII 43) no acumulador)

JMI Op (jump immediate) ==> CI <--- Op = carrega o CI com o valor (hexadecimal) do operando
JMI 1000H ==> CI<--- 1000 = causa um desvio para o endereço 1000 (hexadecimal)
Obs.: O Intel 8080 armazena o byte menos significativo do operando na posição de memória que segue o opcode e o byte mais significativo do operando na segunda posição de memória que segue o opcode.

MVI R, Op (move immediate) ==> R <--- Op = move o valor do operando para o registrador R
MVI B, 7AC1 ==> B <--- 7AC1 (como o operando é de 16 bits, B estará representando o par B, C)

CPI ’C’ (compare immediate) ==> compara os valores do ACC com o caractere ‘C’ (ASCII 43)

LXI Op (load register pair immediate) ==> RP <--- Op = carrega o valor do operando em um par de registradores.
LXI SP, 31FFH ==> SP <--- 31FF (carrega o valor hexadecimal 31FF no Ponteiro de Pilha - SP)

Nota: No Intel 8080, as instruções com endereçamento imediato são sempre codificadas com mnemônicos de 3 letras terminados pela letra I.
Exemplos
instrução de soma ==> mnemônico para endereçamento direto = ADD
instrução de soma ==> mnemônico para endereçamento imediato = ADI;

instrução “move” ==> mnemônico para endereçamento direto = MOV
instrução “move” ==> mnemônico para endereçamento imediato = MVI;

instrução “load” (carrega) ==> mnemônico para endereçamento direto): LDA
instrução “load” ==> mnemônico para endereçamento direto = LDI

Obs.: No Intel 8080, quase todas as instruções imediatas usam o acumulador como operador implícito. As exceções são:
MVI (move immediate) - pode mover o dado para qualquer registrador de trabalho ou posição de memória;
LXI (load register pair immediate) - move um dado de 16 bits (geralmente um endereço) para qualquer par de registradores.

MODO DIRETO
O valor do campo operando indica o endereço do dado na MP.
No Intel 8080, como um endereço requer 16 bits, o operando (no modo direto) terá 16 bits, ocupando 2 células e as instruções no modo de endereçamento direto terão 3 bytes.

DESENHO (a incluir)

Vantagens
a) É aplicado em mais situações que o modo imediato;
b) Requer apenas uma referência à memória para busca do dado (além de uma para a busca da instrução), sendo mais rápido que o modo indireto.

Desvantagens
a) Limitação do endereço da MP que pode ser indicado pelo tamanho do campo operando.
b) É mais lento que o modo imediato.

Utillização
Quando o dado varia de valor a cada execução.

Exemplos de Instruções do Intel 8080:

LDA Op (”load accumulator”), sendo Op um endereço na memória ==> ACC <--- (Op)
(carrega o conteúdo da posição de memória indicada pelo operando no acumulador).
LDA 978A ===> ACC <--- (978A) = carrega no acumulador o conteúdo da posição de memória 978A.

JMP Op ("jump") ==> CI <--- (Op)
JMP 1000H ==> CI<--- (1000H) = causa um desvio para o endereço contido nas posições 1000 e 1001 (hexadecimal) da memória, carregando o conteúdo das posições 1000 e 1001H no CI
Obs: como o CI contém 16 bits (um endereço), serão necessárias DUAS células de memória (uma célula contém 8 bits), o que requer dois ciclos de busca à memória.

MOV R, Op ==> R <--- (Op)
MOV B, 7AC1 ==> B <--- (7AC1), move o conteúdo da posição de memória (8 bits) indicada pelo operando - 7AC1 - para o registrador B (8 bits).

Exercício:
Comparar o efeito das instruções acima no modo direto com as instruções equivalentes no modo imediato, em termos de acessos à memória.

Resp: No modo de endereçamento direto, são necessários mais de 1 acessos à MP para a busca do dado, sendo 1 no ciclo de busca para busca do operando e pelo menos 1 no ciclo de execução para a busca do dado propriamente dito. No modo imediato, é necessário apenas um acesso à memória no ciclo de busca para a busca do dado (o operando é o próprio dado). Não é necessário nenhum acesso de busca à memória no ciclo de execução.

MODO INDIRETO
O campo operando contém um endereço de memória cujo conteúdo é o endereço do dado a ser operado.
Portanto, há um duplo endereçamento. O endereço intermediário é chamado ponteiro (“pointer”)

DESENHO (a incluir)

Exemplo:
LDID Op ==> ACC <--- ((Op))

São necessários 3 ou mais acessos à memória: 1 para buscar o opcode, 1 (ou 2, quando for uma referência à memória) para buscar o operando (Op) e mais 1 para buscar o dado ((Op)) propriamente dito (ou 2, quando o dado for um endereço de memória; por exemplo, quando for uma instrução de desvio).

Vantagem
a) Permite implementar estruturas de organização de dados mais complexas, mais sofisticadas.
b) Elimina a limitação de células endereçáveis.

Desvantagem
Requer maior quantidade de acessos à MP para completar o ciclo de execução da instrução, acarretando que o tempo requerido para a execução da instrução é maior.

Obs.1: É possível haver várias indireções. Em algumas máquinas, existe 1 bit que sinaliza no caso de existirem várias Indireções. Enquanto este bit for 0, continua com as indireções, até encontrá-lo ligado.
Obs.2: O Intel 8080 somente dispõe de instruções com modo de endereçamento indireto usando registradores como ponteiro. Os exemplos dessa aplicação são apresentados no item sobre ENDEREÇAMENTO POR REGISTRADOR.

Utilização
Manutenção de ponteiro de dados

Exemplo:
Relação de dados a serem movimentados para novas posições de memória (por exemplo, elementos de vetores), basta modificar o valor da célula endereçada pela instrução (não é necessário mudar o valor do operando).

TABELA COMPARATIVA DOS MODOS DE ENDEREÇAMENTO (a incluir).

ENDEREÇAMENTO POR REGISTRADOR
Existem outros modos de endereçamento, que usam registradores para indicar a posição onde estão os dados. Os modos de endereçamento direto e indireto por registrador funcionam de forma semelhante aos modos de endereçamento direto e indireto vistos anteriormente (em que o operando aponta para uma posição de memória), porém o operando aponta para um registrador (onde está o dado - endereçamento direto - ou então faz referência à memória - endereçamento indireto).

Modo por registrador direto
O operando aponta para um registrador, o qual contém o dado.

Modo por registrador indireto
O operando aponta para um registrador, o qual contém um endereço de memória (ponteiro) para o dado.

Vantagens
Maior velocidade / rapidez de execução - o acesso ao registrador é muito mais rápido que o acesso à memória.
Economia de espaço de armazenamento de instrução (o tamanho da instrução é menor porque como são poucos registradores, são menos bits para seus endereços).

Desvantagem
Não são adequados para transferência de variáveis da MP para ULA.
Pequeno número de registradores - se forem muitos os dados endereçados por registrador, os registradores disponíveis podem não ser suficientes.

Utilização
Implementação de contadores.

Exemplo de uso:
vetor E(1) ... E (100)
Ri contém E ( i ) para incrementar e percorrer o vetor

Obs.: No Intel 8080, a identificação do registrador envolvido na operação faz parte do próprio opcode.
Incluir tabela!

Exemplos
Os exemplos usam instruções do Intel 8080:
ADD r (add register) ==> (ACC) <--- (ACC) + (r) - soma o conteúdo do registrador r ao conteúdo do acumulador (endereçamento por registrador, direto)
ADD M (add memory) ==> (ACC) <--- (ACC) + ((M)) - soma o conteúdo da posição de memória indicada pelo registrador M ao conteúdo do acumulador (endereçamento por registrador, indireto)
INR M (increment memory) ==> ((M)) <--- ((M)) + 1 - incrementa o conteúdo da posição de memória indicada pelo registrador M (endereçamento por registrador, indireto)
DCR r (decrement register) ==> (r) <--- (r) - 1 - decrementa o conteúdo do registrador r (endereçamento por registrador, direto)
MOV r1, r2 (move register) ==> (r1) <--- (r2) - o conteúdo do registrador r2 é copiado para o registrador r1 (endereçamento por registrador, direto).
MOV M, r (move to memory) ==> ((M)) <--- (r) - o conteúdo do registrador r é copiado para a posição de memória cujo endereço está no registrador M (endereçamento por registrador, indireto).

MODO INDEXADO
O endereço de cada elemento é obtido através da soma do campo Operando com o conteúdo de um registrador (Registrador de Índice).
O endereço de cada elemento (por exemplo, de um vetor) é a soma (antes da colocação do endereço no REM) do valor do campo operando com o conteúdo de um registrador (escolhido como registrador índice).

Vantagem
Rapidez na execução das instruções de acesso aos dados (a alteração dos endereços é realizada na UCP.

Utilização
Manipulação de estruturas de dados mais sofisticadas (vetores).

DESENHO (a incluir)

Obs.: O Intel 8080 não possui nenhuma instrução com modo de endereçamento indexado, o qual somente foi introduzido na família Intel a partir do 8086.
Exemplos
LDX Ri, Op ==> ACC <--- ((Op) + (Ri))
ADX Ri, Op ==> ACC <--- ACC + ((Op) + (Ri))

MODO BASE + DESLOCAMENTO
Utiliza um registrador chamado Registrador de Base, que contém o endereço base na MP e um operando, que contém o deslocamento do dado em relação à base.

Utilização
É usado para relocação de programas: define endereço inicial da área do programa e o endereço inicial da área de dados (pode ser utilizado um registrador para endereços e um para dados)

Nota: Os microprocessadores Intel (após 8086/8) usam registradores específicos como registradores-base. Estes Registradores de Base são utilizados para implementar o endereçamento de memória e a segmentação da memória em páginas de 64 kbytes.

Diferenças conceituais entre os modos Indexado e Base + Deslocamento

Modo lndexado
Acesso a diferentes dados pela alteração do endereço através do registrador-índice, com um único valor no operando.
É utilizado para manipulação de estruturas de dados.

Modo Base + Deslocamento
Um único valor no registrador-base e valores diferentes no campo deslocamento da instrução.
É utilizado para relocação de programas.

IDENTIFICAÇÃO DO MODO DE ENDEREÇAMENTO DA INSTRUÇÃO
O Código de Operação identifica o modo de endereçamento, através de seu mnemônico e do correspondente código binário.

Determinados bits no opcode podem indicar o modo de endereçamento ou a instrução pode possuir um campo específico para indicar o modo de endereçamento, através de códigos em bits. O registrador utilizado no endereçamento também pode ser indicado por bits determinados no opcode.

Comparação dos Efeitos dos Modos de endereçamento - Exemplo (máquina hipotética)
Qual será o valor carregado no acumulador quando forem executadas as seguintes instruções:

LDI Op ==> (ACC) <--- Op (modo de endereçamento Imediato)
LDA Op ==> (ACC) <--- (Op) (modo de endereçamento direto)
LDID Op ==> (ACC) <--- ((Op)) (modo de endereçamento Indireto)
LDR Op ==> (ACC) <--- (R) (modo de endereçamento Direto por Registrador)
LDIR Op ==> (ACC) <--- ((R)) (modo de endereçamento Indireto por Registrador)
LDX Op ==> (ACC) <--- ((Ri) + (Op)) (modo de endereçamento Indexado)
LDB Op ==> (ACC) <--- ((Rb) + (Op)) (modo de endereçamento Base + Deslocamento)

Conteúdo da memória no início da instrução:

Conteúdo dos registradores no início da instrução

Resposta:

Nota: Algumas instruções usam uma combinação de modos de endereçamento.
Instrução CALL - endereçamento direto (ou imediato) + por registrador indireto
endereçamento direto - especifica o endereço da sub-rotina desejada
endereçamento por registrador indireto - é o Ponteiro da Pilha
CALL copia (“push”) o conteúdo corrente do CI para uma posição da MP especificada pelo ponteiro da pilha (Stack Pointer).
Ver páginas sobre [Pilha] e [Processamento de Sub-rotinas]

Efeitos de Temporização dos Modos de Endereçamento
O modo de endereçamento afeta o tempo requerido para executar uma instrução e a memória requerida para seu armazenamento

Instruções que usam endereçamento implícito ou por registrador são executadas muito rápido, pois trabalham direto com o hardware do processador e seus registradores. A instrução toda pode ser buscada (“fetched”) em um único ciclo de busca (um único acesso à memória). O número de acessos à memória é o mais importante fator no consumo de tempo de execução da instrução.

Cada ciclo de acesso à memória busca uma célula e implica em um número variável de estados, cujo tempo de duração depende da frequência do clock. Cada instrução consome um determinado número de ciclos de UCP.

Exemplo:
A instrução CALL requer 5 acessos à memória, sendo 3 para buscar a instrução (opcode mais operando de 2 bytes) e mais 2 para salvar ("push") o conteúdo (2 bytes) do CI (Program Counter) para o ponteiro da pilha (Stack Pointer).