1 O Conjunto de Instruções ISA – Instruction Set Architecture.

1

O Conjunto de Instruções

ISA – Instruction Set Architecture

2

Conjunto de instruções

Alguns conceitos... Linguagem máquina

Combinação de ‘0’s e ‘1’s organizados segundo palavras que são as instruções que o processador percebe

Linguagem assembly Linguagem que permite uma correspondência directa ao

código máquina, e que para todos os efeitos é mais fácil de programar do que escrever directamente os ‘0’s e ‘1’s

Arquitectura Hardware (circuitos) Organização (datapath, unidade de controlo) Conjunto de instruções ou ISA – Instruction Set Architecture

3

Conjunto de instruções

Até agora, lidámos com o conjunto de instruções do processador MAC-1

É preciso ter em conta que CPUs diferentes têm arquitecturas diferentes e conjuntos de instruções diferentes Por exemplo, o conjunto de instruções de um processador

Intel Core 2 Duo é diferente do conjunto de instruções de um processador ARM (usado em telemóveis)

Mas apesar de os conjuntos de instruções serem diferentes, os tipos de instruções disponíveis em cada conjunto são idênticos

4

Instruções típicas

Transferências de dados

Instrução Mnemónica

Load LD, LW

Store ST, LW

Transferir (mover) MOV

Push PUSH

Pop POP

Trocar XCH, SWAP

Notas:

Tipicamente, quando são utilizadas instruções do tipo Load / Store, a instrução MOV apenas permite transferências entre registos (ou então não existe).

5


Aritméticas


Incrementar INC

Decrementar DEC

Somar ADD

Subtrair SUB

Multiplicar MUL

Dividir DIV

Simétrico NEG

Notas:

Geralmente existem instruções distintas para inteiros e reais (vírgula flutuante)

Exemplo:

IADD (inteiros)

FADD (vírgula flutuante)

Atenção a NEG, cuja finalidade costuma ser calcular o simétrico (complemento para 2) e não a negação...

6


Lógicas


Clear CLR

Set SET

Negação NOT

AND AND

OR OR

XOR XOR

Notas:

CLR – colocar um registo a ‘0’

SET – colocar um registo a ‘1’

Existem tipicamente outros tipos de CLRs e SETs que visam colocar a ‘0’ ou a ‘1’ apenas um bit do estado (flag) da unidade funcional

7


Controlo de programa


Jump JMP

Jump if equal JE

Jump if not equal JNE

Jump if zero JZ

Jump if not zero JNZ

Jump if above JA

etc...

Notas:

Muitos processadores utilizam a designação branch em vez de jump. Na maioria das vezes as designações são sinónimas.

Noutros podem existir diferenças: por exemplo, jump poderia ser um salto para um endereço absoluto e branch um salto para um endereço relativo.

8


Procedimentos


Chamar procedimento CALL

Retornar RETN


Jump and link JAL

Jump register JR

CALL / RETN – o endereço de retorno é colocado / lido da pilha.

JAL / JR – o endereço de retorno é colocado / lido de num registo.

9

Formatos de instrução

As instruções encontram-se organizadas segundo campos com significado específico: Código de operação (opcode)

Indica qual é o tipo ou finalidade da instrução

Operandos Origem e destino dos dados (endereços ou registos) Valores constantes que vão na própria instrução

Modo de endereçamento Indica o modo como devem ser interpretados os operandos Muitas vezes está incluído no próprio opcode e não num campo em

separado

ModoOpcode Operando 1 Operando 2

10


Exemplos de algumas instruções já conhecidas LODD x

LOCO c

INSP y

xxxxxxxxxxxx0000

Opcode(4 bits)

Posição de memória a ler(12 bits)

cccccccccccc1110

Opcode(4 bits)

Constante a carregar(12 bits)

yyyyyyyy1111

Opcode(4 bits)

Posição de memória a ler(12 bits)

0011

Exp. do opcode(4 bits)

11


É habitual classificar os formatos de instrução de acordo com o número de operandos 1, 2, ou 3 operandos …ou mesmo sem operandos

(muito usadas em arquitecturas baseadas em stack)

Exemplo:

Considere que se pretende calcular:

M[x] ← (M[a] + M[b]) (M[c] - M[d])

12


com 3 operandos... Pode-se especificar um destino e duas fontes

ADD R1, a, b # R1 ← M[a] + M[b]

SUB R2, c, d # R2 ← M[c]+ M[d]

MUL x, R1, R2 # M[x] ← R1 R2

Opcode Destino Fonte 1 Fonte 2

Nota:

Assumiu-se que as fontes / destino dos dados podem ser endereços ou registos. Como veremos mais à frente, não é uma assunção muito realista, uma vez que obriga a instruções com comprimento demasiado longo.

13


com 2 operandos... Especifica-se uma fonte e um destino

MOV R1, a # R1 ← M[a]

ADD R1, b # R1 ← R1 + M[b]

MOV R2, c # R2 ← M[c]

SUB R2, d # R2 ← R2 – M[d]

MUL R1, R2 # R1 ← R1 R2

MOV x, R2 # M[x] = R2

Nota: assumiu-se que o registo destino acumula resultados, pelo que serve de fonte, de uma forma implícita

Opcode Destino Fonte 1

14


com 1 operando... Vão sendo guardados os resultados num registo

acumulador Especifica-se apenas uma fonte ou um destino

LOAD a # AC ← M[a]

ADD b # AC ← AC + M[b]

STORE x # M[x] ← AC

LOAD c # AC ← M[c]

SUB d # AC ← AC + M[d]

MUL x # AC ← AC M[x]

STORE x # M[x] ← AC

Opcode Destino ou fonte

15


sem operandos... Todas as operações são feitas com recurso à pilha As instruções fazem implicitamente pop dos operandos e push

dos resultados

PUSH a # TOS ← M[A]

PUSH b # TOS ← M[B]

ADD # TOS ← TOS-1 + TOS

PUSH c # TOS ← M[C]

PUSH d # TOS ← M[D]

SUB # TOS ← TOS-1 – TOS

MUL # TOS ← TOS-1 TOS TOS – Topo da Pilha (Top of Stack)

POP x # M[X] ← TOS TOS-1 – 2º valor na pilha (a contar do topo)

16


Curiosidade… Para facilitar a implementação de código sem

operandos, pode-se utilizar a notação RPN(Reverse Polish Notation)

Exemplo:

a expressão

(A+B) (C-D)

é equivalente à seguinte, em RPN:

A B + C D -

A ordem pela qual aparecem os operandos e as operações em RPN é a mesma que se segue num programa idêntico ao anterior

17


Como maximizar o número de instruções do conjunto? Expansão do opcode

Aproveita-se o facto de nem todas as instruções terem o mesmo número de operandos

Para se expandir o opcode, usa-se o espaço deixado por campos que não são utilizados

Resulta assim um opcode com mais bits, possibilitando um maior número de instruções

Instruções de comprimento variável A ideia é ter instruções cujo comprimento varia consoante as

necessidades (exemplo: dentro do mesmo conjunto, ter instruções de 16, 32 e 64 bits)

18


Exemplo de expansão do opcode Vamos supor que se pretende projectar um conjunto

de instruções com os seguintes formatos: Formato I

Formato II

Opcode Operando 1 Operando 2

4 bits 8 bits 8 bits

Opcode Operando 1

4 bits 2 bits 10 bits

Quantas Instruções serão possíveis para cada um dos formatos ?

19


Exemplo de expansão do opcode (cont.) Se fossem todas do formato I teríamos 24 = 16 instruções

diferentes Aproveitando o espaço de 2 bits disponíveis no formato II para

expansão do opcode, existem outras possibilidades: 15 de formato I + 4 do formato II 14 de formato I + 8 do formato II 13 de formato I + 12 do formato II …

De uma forma geral teríamos, neste caso: 24–k instruções do formato I + k22 instruções do formato II

Repare que os expoentes ‘4’ e ‘2’ correspondem ao número de bits do opcode e da expansão, respectivamente

20


Algumas considerações… Em geral, se um conjunto de instruções permite mais operandos,

menor será o número de instruções num programa No entanto, maior será o comprimento das instruções, de forma a

incluir todos os operandos necessários

Quanto menor for o comprimento das instruções, Maior rapidez a efectuar o fetch (pois podem ser lidas mais

instruções de uma só vez)

Haverá mais instruções, mas na prática irão ocupar menos espaço, pois são mais pequenas

Mais difícil será a possibilidade de futuras expansões ao conjunto de instruções (factor importante do ponto de vista comercial)

O normal é tentar que chegar a uma solução de compromisso

21


Alguns exemplos reais Intel (x86) – max. 2 operandos PowerPC (Wii, Xbox 360) – max. 3 operandos Cell (Playstation 3) – max. 4 operandos (maioria 3) TMS (Processador de sinal) – max. 3 operandos ARM – max. 3 operandos (maioria 2)

...e virtuais Java Virtual Machine – a maioria sem operandos MAC-1– max. 1 operando MIPS – max. 3 operandos

1 O Conjunto de Instruções ISA – Instruction Set Architecture.

Documents

Transcript of 1 O Conjunto de Instruções ISA – Instruction Set Architecture.