Defina resumidamente:
endereçamento imediato
endereçamento direto
endereçamento indireto
endereçamento de registrador
indireto por registradores.
endereçamento por deslocamento.
endereçamento relativo

Passo 1

Você pediu definições resumidas de 7 modos de endereçamento: endereçamento imediato, direto, indireto, de registrador, indireto por registradores, por deslocamento e relativo. O que devo entregar: uma explicação passo a passo para cada modo (para você entender na prova) e, ao final, respostas curtas e objetivas (uma linha cada) com as definições pedidas. Não vou pedir nada a você — sigo com as explicações e exemplos.

Passo 2

Antes de começar, vamos combinar a linguagem básica para você não se perder: o que é “modo de endereçamento” e o que significa “endereço efetivo”.
  • Uma instrução típica tem um código de operação (opcode) e um campo que indica onde está o operando (o que a instrução vai usar). O “modo de endereçamento” diz como interpretar esse campo.
  • “Operando” = dado usado pela instrução (um número, ou o conteúdo de memória, ou um registrador).
  • “Endereço efetivo” (EA) = o endereço de memória onde está o operando real (se o operando estiver em memória). Nem sempre precisamos de EA (por exemplo, se o operando já é o valor imediato).
    Exemplo comum de instrução: LOAD R_1,\;X, que carrega em R_1 o valor indicado por X — a diferença entre os modos é o que exatamente X representa (um valor, um endereço, um ponteiro, um registrador, etc.). Agora vamos a cada modo com calma.

Passo 3

O que é: o campo da instrução contém o próprio valor que será usado como operando — não é endereço, é dado imediato.
Exemplo de sintaxe: LOAD R_1,\;\#5 (aqui \#5 indica o valor imediato 5).
Como funciona passo a passo:
  1. A CPU lê a instrução.
  2. Interpreta o campo como o valor 5.
  3. Coloca 5 em R_1.
    Prós e contras:
  • Vantagem: é rápido (nenhuma leitura adicional de memória).
  • Desvantagem: o tamanho do campo na instrução limita o tamanho do valor imediato e não serve para modificar valores na memória (só insere constantes).
    Dica de prova: reconheça pela presença do símbolo que indica imediato ( \#, ou sintaxe sem parênteses) e porque o campo é o próprio valor.

Passo 4

O que é: o campo da instrução contém um endereço de memória onde está o operando. O EA é exatamente o valor do campo.
Exemplo: LOAD R_1,\;1000 significa "carregue em R_1 o conteúdo de memória no endereço \,1000".
Como funciona passo a passo:
  1. CPU lê o campo e toma 1000 como EA.
  2. Lê memória em \,1000 e copia o conteúdo para R_1.
    Prós e contras:
  • Simples de entender e codificar.
  • Ineficiente para tabelas/arrays porque cada elemento precisa de um endereço completo na instrução.
    Dica de prova: se o operando aparece como um número sem símbolos extras e é tratado como endereço, é endereçamento direto.

Passo 5

O que é: o campo da instrução contém um endereço que, por sua vez, guarda o endereço efetivo — ou seja, há um nível extra de indireção (como um ponteiro).
Exemplo de sintaxe: LOAD R_1,\;(2000). Aqui o parêntese indica que em memória no endereço \,2000 está guardado outro endereço, digamos \,3500; o dado real vem de memória em \,3500.
Como funciona passo a passo:
  1. Leia o campo: obtenha \,2000.
  2. Acesse memória em \,2000 e recupere o valor contido ali (por exemplo \,3500).
  3. Use \,3500 como EA e leia memória em \,3500 para obter o operando.
    Quando usar: quando a instrução precisa seguir um ponteiro (listas, tabelas de ponteiros). Cuidado na prova: verifique se há dois acessos à memória (um para obter o ponteiro, outro para obter o dado).

Passo 6

O que é: o operando está em um registrador; o campo da instrução identifica qual registrador.
Exemplo: MOV R_1,\;R_2 ou ADD R_1,\;R_2 — aqui o conteúdo de R_2 é usado diretamente.
Como funciona passo a passo:
  1. A instrução especifica o número do registrador (por exemplo R_2).
  2. O valor contido em R_2 é lido e usado (sem acessar memória).
    Prós e contras:
  • Muito rápido (registradores são rápidos).
  • Número de registradores é limitado; algoritmo pode precisar mover dados para/da memória.
    Dica de prova: se a operand field referencia um registrador (normalmente por nome ou número) e não há parênteses/hashtags, é registrador direto.

Passo 7

O que é: parecido com indireto em memória, mas o “ponteiro” está num registrador: o campo indica um registrador que contém o endereço efetivo.
Exemplo: LOAD R_1,\;(R_2) significa: pegue o conteúdo de R_2 (por exemplo \,3000), use isso como EA e leia memória em \,3000.
Como funciona passo a passo:
  1. Leia o registrador R_2; ele contém um endereço \,3000.
  2. Acesse memória em \,3000 e copie o dado para R_1.
    Vantagem: menos acessos à memória para obter o ponteiro (já está no registrador), útil para percorrer vetores, listas usando ponteiros mantidos em registradores.

Passo 8

O que é: a instrução fornece um deslocamento (offset) e indica um registrador base; o EA é a soma do conteúdo do registrador base com o deslocamento.
Exemplo de sintaxe clássica: LOAD R_1,\;8(R_2). Se R_2 contém \,1000, então EA = 1000 + 8 = 1008 e o dado vem de memória em \,1008.
Como funciona passo a passo:
  1. Leia o deslocamento imediato (por exemplo \,8) e o registrador base R_2.
  2. Calcule EA = conteúdo( R_2) + deslocamento.
  3. Leia memória em EA e carregue o dado.
    Por que serve: é perfeito para endereçar elementos de arrays e campos de estruturas. Em provas, pratique somas pequenas à mão (ex.: se R_2=200 e deslocamento =12, EA =212).

Passo 9

O que é: o endereço efetivo é calculado em relação ao contador de programa ( PC) — tipicamente usado para saltos (branches) e chamadas relativas ao código atual.
Exemplo: em uma instrução de salto, você pode ter BEQ offset. O EA do salto é EA = PC + offset (onde PC normalmente já aponta para a próxima instrução).
Como funciona passo a passo:
  1. Leia o offset (geralmente um número pequeno, pode ser com sinal).
  2. Some ao PC (ou ao PC da próxima instrução, dependendo da arquitetura) para obter o destino.
  3. Salte para esse destino se a condição for satisfeita.
    Vantagens: permite código position-independent e offsets pequenos economizam bits na instrução. Em provas, verifique se o offset é relativo ao PC atual ou ao PC+4 (varia por arquitetura).

Passo 10

  • Identifique pelo símbolo: \# ou “immediate” → imediato; parênteses em endereço → indireto; parênteses em registrador → registrador indireto; sintaxe 8(R_2) → deslocamento; ausência de parênteses e sem \# → direto ou registrador direto conforme o campo.
  • Exemplos rápidos (relações sintáticas):
    • Imediato: LOAD R_1,\;\#10 → carrega valor 10.
    • Direto: LOAD R_1,\;1000 → carrega memória[ 1000].
    • Indireto: LOAD R_1,\;(2000) → pega endereço em memória[ 2000], depois lê dali.
    • Registrador: MOV R_1,\;R_2 → copia conteúdo de R_2.
    • Registrador indireto: LOAD R_1,\;(R_2) R_2 contém endereço.
    • Deslocamento: LOAD R_1,\;8(R_2) → EA = R_2 + 8.
    • Relativo: BRANCH offset → destino = PC + offset.
      Força aí — você já sabe o que olhar no enunciado para identificar cada modo. Agora a resposta curta e direta.

Resposta

Endereçamento imediato: o campo da instrução contém o próprio valor do operando (ex.: LOAD R_1,\;\#5 carrega o valor 5).
Endereçamento direto: o campo da instrução contém o endereço de memória onde está o operando (ex.: LOAD R_1,\;1000 lê memória[ 1000]).
Endereçamento indireto: o campo contém um endereço que aponta para outra célula que guarda o endereço efetivo; há um nível adicional de indireção (ex.: LOAD R_1,\;(2000)).
Endereçamento de registrador: o operando está no próprio registrador indicado pela instrução (ex.: MOV R_1,\;R_2 usa o conteúdo de R_2).
Indireto por registradores: a instrução indica um registrador cujo conteúdo é um endereço em memória; a CPU usa esse endereço para acessar o operando (ex.: LOAD R_1,\;(R_2)).
Endereçamento por deslocamento: o EA é a soma do conteúdo de um registrador base com um deslocamento imediato (ex.: LOAD R_1,\;8(R_2) com EA = conteúdo( R_2) + 8).
Endereçamento relativo: o EA é calculado somando um offset ao contador de programa ( PC); muito usado em saltos (ex.: destino = PC + offset).

Exercícios relacionados