O Conjunto de Instruções

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 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. Instruções típicas • Aritméticas 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. Instruções típicas • Lógicas 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. Instruções típicas • Controlo de programa 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. Instruções típicas • Procedimentos 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

10. Formatos de instrução • Exemplos de algumas instruções já conhecidas • LODD x • LOCO c • INSP y

11. Formatos de instrução • É 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. Formatos de instrução • 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 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. Formatos de instrução • 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

14. Formatos de instrução • 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

15. Formatos de instrução • 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 TOSTOS – Topo da Pilha (Top of Stack) POP x # M[X] ← TOS TOS-1 – 2º valor na pilha (a contar do topo)

16. Formatos de instrução • 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. Formatos de instrução • 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. Formatos de instrução • 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 Quantas Instruções serão possíveis para cada um dos formatos ?

19. Formatos de instrução • Exemplo de expansão do opcode (cont.) • Se fossem todas do formato I teríamos 24 = 16instruçõ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 + k22 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. Formatos de instrução • 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. Formatos de instrução • 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