Instituto Politécnico Superior

Curso: Engenharia Informática e de Telecomunicações

Cadeira: Fundamentos de Algoritmos e Programação

Tema: Arquitetura do conjunto de instruções (ISA)

Nomes:
Adil Aly Issufo Bacar
Elvin Miguel Monteiro Trindade
Silvio Abel Mabunda Junior

Docente: GRAÇANE XAVIER MUHATE

Maputo, 2021
Índice

Introdução.........................................................................................................................3

Arquitetura do conjunto de instruções (ISA).......................................................................4

Classificação de ISAs..........................................................................................................4

Instruções..........................................................................................................................5

Tipos de instrução......................................................................................................................5

Manuseio de dados e operações de memória.............................................................................5

Operações aritméticas e lógicas..................................................................................................5

Controle de operações de fluxo..................................................................................................5

Instruções do coprocessador......................................................................................................6

Número de operandos.......................................................................................................6

0-operando................................................................................................................................6

1 operando.................................................................................................................................6

2 operandos...............................................................................................................................6

3 operando.................................................................................................................................6

Mais operandos.........................................................................................................................7
Introdução
Os programadores usam uma linguagem de alto nível para desenvolver programas, para que o
programa seja executável, ele devera ser convertido em linguagem de máquina (binário).
Cada CPU tem um conjunto de instruções que representa o tipo de operações que o CPU
pode funcionar, e essas instruções são representadas na forma mnemónica ou em abreviação,
por exemplo, a instrução de adição é representada por “ADD” e subtração “SUB”.
ADD R1, R2, R3 significa adicionar conteúdos de R2 COM R3, registar e guardar os
resultados em R1. R1, R2 e R3 são chamados de operandos

Os fabricantes de CPUs publicam um documento que contém informações sobre o

processador, como lista de registros, função de cada registro, tamanho do barramento de
dados, tamanho do barramento de endereço e lista de instruções que podem ser executadas
pela CPU. Cada CPU tem um conjunto de instruções conhecido que um programador pode
usar para escrever um programa em linguagem assembly. Os conjuntos de instruções são
específicos para cada tipo de processador. Os processadores Pentium usam um conjunto de
instruções diferente do processador ARM. As instruções classificadas são baseadas no
número de operandos ou tipo de operação
Arquitetura do conjunto de instruções (ISA)

Em ciência da computação , uma arquitetura de conjunto de instruções ( ISA ) é um modelo

abstrato de um computador. Também é conhecido como arquitetura ou arquitetura de
computador. A realização de um ISA, como uma unidade de processamento central (CPU), é
chamada de implementação .

Em geral, um ISA define os tipos de dados suportados, os registros, o suporte de hardware

para gerenciar a memória principal, recursos fundamentais (como a consistência da memória ,
modos de endereçamento , memória virtual ) e o modelo de entrada / saída de uma família de
implementações do ISA.

Um ISA especifica o comportamento do código de máquina em execução nas

implementações desse ISA de uma forma que não depende das características dessa
implementação, fornecendo compatibilidade binária entre as implementações. Isso permite
várias implementações de um ISA que diferem em desempenho , tamanho físico e custo
monetário (entre outras coisas), mas que são capazes de executar o mesmo código de
máquina, de modo que uma máquina de baixo desempenho e custo pode ser substituída por
uma máquina de alto custo e alto desempenho sem a necessidade de substituir o software. Ele
também permite a evolução das microarquiteturas das implementações daquele ISA, de modo
que uma implementação mais recente e de alto desempenho de um ISA possa executar um
software executado em gerações anteriores de implementações.

Se um sistema operacional mantiver uma interface binária de aplicativo (ABI) padrão e

compatível para um determinado ISA, o código de máquina desse ISA e do sistema
operacional será executado em futuras implementações desse ISA e em versões mais recentes
desse sistema operacional. No entanto, se um ISA oferece suporte à execução de vários
sistemas operacionais, não garante que o código de máquina de um sistema operacional seja
executado em outro sistema operacional, a menos que o primeiro sistema operacional ofereça
suporte à execução de código de máquina criado para o outro sistema operacional.

Um ISA pode ser estendido adicionando instruções ou outros recursos, ou adicionando

suporte para endereços maiores e valores de dados; uma implementação do ISA estendido
ainda será capaz de executar código de máquina para versões do ISA sem essas extensões. O
código de máquina que usa essas extensões só será executado em implementações que
oferecem suporte a essas extensões.

Classificação de ISAs
Uma ISA pode ser classificada de várias maneiras diferentes. Uma classificação comum é por
complexidade arquitetônica .
Um computador com conjunto de instruções complexas (CISC) tem muitas instruções
especializadas, algumas das quais podem ser raramente usadas em programas práticos.
Um computador de conjunto de instruções reduzido (RISC) simplifica o processador
implementando de forma eficiente apenas as instruções que são frequentemente usadas em
programas, enquanto as operações menos comuns são implementadas como sub-rotinas,
tendo seu tempo de execução de processador adicional resultante compensado por uso
infrequente.

Outros tipos incluem arquiteturas de palavra de instrução muito longa (VLIW) e arquiteturas
de palavra de instrução longa intimamente relacionadas (LIW) e de computação de instrução
explicitamente paralela (EPIC). Essas arquiteturas buscam explorar o paralelismo em nível de
instrução com menos hardware do que RISC e CISC, tornando o compilador responsável pela
emissão e programação de instruções.

Arquiteturas com ainda menos complexidade foram estudadas, como o computador de

conjunto de instruções mínimo (MISC) e um computador de conjunto de instruções (OISC).
Esses são tipos teoricamente importantes, mas não foram comercializados.

Instruções
A linguagem de máquina é construída a partir de instruções ou instruções discretas. Na
arquitetura de processamento, uma determinada instrução pode especificar:

-Registros específicos (para funções aritméticas, de endereçamento ou de controle)

-Locais de memória específicos (ou deslocamentos para eles)
-Modos de endereçamento específicos (usados para interpretar os operandos)
Operações mais complexas são construídas combinando essas instruções simples, que são
executadas sequencialmente ou de outra forma direcionadas por instruções de fluxo de
controle .

Tipos de instrução
Exemplos de operações comuns a muitos conjuntos de instruções incluem:

Manuseio de dados e operações de memória

-Defina um registro com um valor constante fixo.
-Copie dados de um local da memória ou um registro.
-Leia e grave dados de dispositivos de hardware.

Operações aritméticas e lógicas

-Adicão, subtracão, multiplicão ou divisão dos valores de dois registradores, colocando o
resultado em um registrador, possivelmente configurando um ou mais códigos de condição
em um registrador de status.
-Incremento, decremento em alguns ISAs, salvando a busca de operando em casos triviais.
-Realize operações bit a bit (por exemplo, pegando a conjunção e disjunção de bits
correspondentes em um par de registradores, pegando a negação de cada bit em um
registrador).
-Comparar dois valores em registradores (por exemplo, para ver se um é menor ou se eles são
iguais).
-Instruções de ponto flutuante s para aritmética em números de ponto flutuante.

Controle de operações de fluxo

-Desvie para outro local no programa e execute as instruções lá.
-Desviar condicionalmente para outro local se uma determinada condição for mantida.
-Ramifique indiretamente para outro local.
-Chame outro bloco de código, enquanto salva a localização da próxima instrução como um
ponto para o qual retornar.
Instruções do coprocessador
-Carregar / armazenar dados de e para um coprocessador ou trocar com registradores de CPU.
-Execute operações de coprocessador.

Número de operandos
Os conjuntos de instruções podem ser categorizados pelo número máximo de operandos
explicitamente especificados nas instruções.

(Nos exemplos a seguir, a , b e c são endereços (diretos ou calculados) que se referem a

células de memória, assim por diante se referem a registros de máquina.)

C=A+B

0-operando ( máquinas de endereço de zero ), assim chamadas máquinas de pilha :

Todas as operações aritméticas decorrer nos um top ou duas posições na pilha: push a, push
b, add, pop c.
C = A+B precisa de quatro instruções . Para máquinas de pilha, os termos "operando 0" e
"endereço zero" se aplicam a instruções aritméticas, mas não a todas as instruções, pois as
instruções push e pop de 1 operando são usadas para acessar a memória.

1 operando ( máquinas de um endereço ), as chamadas máquinas acumuladoras , incluem os

primeiros computadores e muitos pequenos microcontroladores :
A maioria das instruções especifica um único operando direito (isto é, constante, um registro
ou uma localização de memória), com o acumulador implícito como o operando da esquerda
(e o destino se houver): load a, add b, store c.
C = A+B precisa de três instruções .

2 operandos - muitas máquinas CISC e RISC se enquadram nesta categoria:

CISC - move A para C ; em seguida, add B a C .
C = A+B precisa de duas instruções . Isso efetivamente 'armazena' o resultado sem uma
instrução de armazenamento explícita .
CISC - Muitas vezes as máquinas são limitados a um operando de memória por instrução:
load a,reg1; add b,reg1; store reg1,c; Isso requer um par de carga / loja para qualquer
movimento de memória, independentemente do address, é um aumento armazenado para um
lugar diferente, como em C = A+B, ou a mesma posição de memória:
A = A+B.
C = A+B precisa de três instruções .
RISC - Requerendo carregamentos de memória explícita, as instruções seriam load a,reg1:;
load b,reg2; add reg1,reg2; store reg2,c.
C = A+B precisa de quatro instruções .

3 operando- permitindo melhor reutilização dos dados:

CISC - Torna-se uma única instrução: add a,b,c
C = A+B precisa de uma instrução .
CISC - Ou, em máquinas limitadas a dois operandos de memória por instrução move a,reg1;
add reg1,b,c;
C = A+B precisa de duas instruções .
RISC - instruções aritméticas usam registradores apenas, portanto, instruções explícitas de
carregamento / armazenamento de 2 operandos são necessárias load a,reg1:; load b,reg2; add
reg1+reg2->reg3; store reg3,c;
C = A+B precisa de quatro instruções.

Ao contrário de 2 operandos ou 1 operando, isso deixa todos os três valores a, b e c em

registros disponíveis para reutilização posterior.

Mais operandos - algumas máquinas CISC permitem uma variedade de modos de

endereçamento que permitem mais de 3 operandos (registradores ou acessos à memória),
como a instrução de avaliação polinomial VAX "POLY".

Devido ao grande número de bits necessários para codificar os três registradores de uma
instrução de 3 operandos, as arquiteturas RISC que têm instruções de 16 bits são
invariavelmente designs de 2 operandos, como o Atmel AVR, TI MSP430 e algumas versões
do ARM Thumb. As arquiteturas RISC que têm instruções de 32 bits são geralmente designs
de 3 operandos, como as arquiteturas ARM , AVR32 , MIPS , Power ISA e SPARC .

Cada instrução especifica um número de operandos (registradores, locais de memória ou

valores imediatos) explicitamente . Algumas instruções fornecem um ou ambos os operandos
implicitamente, como por serem armazenados no topo da pilha ou em um registro implícito.
Se alguns dos operandos são fornecidos implicitamente, menos operandos precisam ser
especificados na instrução. Quando um "operando de destino" especifica explicitamente o
destino, um operando adicional deve ser fornecido. Conseqüentemente, o número de
operandos codificados em uma instrução pode diferir do número matematicamente necessário
de argumentos para uma operação lógica ou aritmética (a aridade ).
Os operandos são codificados na representação "opcode" da instrução ou são fornecidos
como valores ou endereços após o opcode.