Instruções MIPS

Anotações da 2a Edição
OBS: Essas anotações são adaptações do material
suplementar (apresentações PPT) ao Livro do
Hennessy e Patterson. Supõe-se que os estudantes
tenham noções de lógica digital e linguagem
assembly para o entendimento das aulas.
1
Conjunto de Instruções MIPS
2
Aritmética MIPS
•
•
Todas as Instruções tem 3 operandos
Ordem dos operandos é fixa (destino sempre primeiro)
Exemplo:
C code:
C = A + B
MIPS code:
add $s0, $s1, $s2
(associado a variáveis definidas pelo compilador)
3
Aritmética MIPS
•
•
•
•
Princípios de design: simplicidade favorece a regularidade. Por que?
Obviamente, isto complica algumas coisas...
C code:
A = B + C + D;
E = F - A;
MIPS code:
add $t0, $s1, $s2
add $s0, $t0, $s3
sub $s4, $s5, $s0
Operandos devem ser registradores, e só existem 32 deles
Princípio de Projeto: quanto menor, mais rápido!
Por que?
4
Registradores x Memória
•
•
•
Operandos das Instruções Aritméticas devem ser registradores,
— Somente 32 registradores estão disponíveis
O Compilador associa variáveis com registradores...
O que significa um programa com muitas variáveis?
Control
Input
Memory
Datapath
Processor
Output
I/O
5
Organização da Memória
•
•
•
Memória: enorme vetor unidimensional acessado por endereços.
Endereço de memória = índice para o vetor
“Endereçar um Byte" = índice que aponta para um byte da memória.
0
1
2
3
4
5
6
...
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
8 bits of data
6
Organização da Memória
•
•
Bytes são interessantes, mas geralmente o acesso é feito a
“palavras” mais longas que 1 byte
Como vimos, para o MIPS, a palavra é de 32 bits (4 bytes).
•
•
•
0 32 bits of data
registradores armazenam 32 bits de dados
4 32 bits of data
8 32 bits of data
12 32 bits of data
...
232 bytes com endereços byte de 0 a 232-1
230 palavras com endereços 0, 4, 8, ... 232-4
Palavras são alinhadas:
Assim, o que representam os 2 bits menos significativos do
endereço de uma palavra?
7
Instruções
•
Instruções load (trazer de) e store (enviar para)
•
Exemplo:
•
•
C code:
A[12] = h + A[12];
MIPS code:
lw $t0, 36($s3)
add $t0, $s2, $t0
sw $t0, 36($s3)
O destino da palavra ($t0) a ser armazenada vem no início da
instrução sw
Lembre-se que todos os operandos aritméticos são registradores e
não endereços de memória!
8
Um 1o. Exemplo
•
Como poderíamos escrever esse código de troca de valor de duas
posições (k e k+1) de um vetor?
swap(int v[], int k);
{ int temp;
temp = v[k]
v[k] = v[k+1];
v[k+1] = temp;
}
swap:
muli $4, $5, 4
add $2, $4, $2
lw $15, 0($2)
lw $16, 4($2)
sw $16, 0($2)
sw $15, 4($2)
jr $31
9
Mas, aprendemos que:
•
MIPS
— Carrega palavras, mas acessa bytes
— Aritmética somente em registradores
•
Instrução
Significado
add $s1, $s2, $s3
sub $s1, $s2, $s3
lw $s1, 100($s2)
sw $s1, 100($s2)
$s1 = $s2 + $s3
$s1 = $s2 – $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1
10
Instruções MIPS
•
•
•
Todas as instruções têm 32 bits
Todas têm opcode (código de instrução) de 6 bits
O modo de endereçamento é codificado juntamente com o opcode
31
26 25
0
opcode
11
Linguagem de Máquina
•
Instruções, assim como registradores de palavras de dados, tem
tamanho de 32 bits
– Exemplo: add $t0, $s1, $s2
– registradores têm números, $t0=8, $s1=17, $s2=18
•
Formato de uma Instrução R típico:
000000 10001
op
•
rs
Observe a ordem na instrução assembly
e na implementação! São diferentes!
10010
01000
00000
100000
rt
rd
shamt
funct
Você pode imaginar o que esses nomes (siglas) indicam?
op – código de operação
rs, rt – registradores fonte
rd – registrador destino
shamt – (shift amount) é usado em instruções de deslocamento
funct – código de função da ULA. É associado ao campo op (no caso de ULA é
00000)
12
Linguagem de Máquina
•
•
•
Considere as instruções load-word e store-word:
– O que o princípio da regularidade nos traz?
– Novo princípio: Bons projetos envolve um compromisso...
Introdução de um novo tipo de formato de Instrução
– Instruções tipo-I para transferência de dados (lw e sw)
– Outros formatos para instruções tipo-R para registradores
Exemplo: lw $t1, 32($s2)
1 0 0 0351 1 1 018
0 1 0 0 190 0 1
op
rs
rt
0 0 0 32
0000000100000
16 bit number
rs – registrador-base para o cálculo do endereço de memória
rt – registrador-destino (para lw) ou registrador-fonte (para sw)
•
Onde está o compromisso?
13
Controle de Fluxo no MIPS
•
•
Pontos de decisão podem criar instruções
– alterar o fluxo de controle,
– i.e., mudar a próxima instrução a ser executada
Endereço “destino” sempre especificado!
•
Instruções MIPS de desvio condicional:
bne $t0, $t1, Label
beq $t0, $t1, Label
•
Exemplo:
if (i!=j) h=i+j;
bne $s0, $s1, Label
...
Label: add $s3, $s0, $s1
...
14
Uso de instruções de controle
15
Controle de Fluxo
•
Instruções MIPS de desvio incondicional (jumps):
j Label
•
Exemplo:
if (i!=j)
h=i+j;
else
h=i-j;
•
beq $s4, $s5, Lab1
add $s3, $s4, $s5
j Lab2
Lab1: sub $s3, $s4, $s5
Lab2: ...
Você poderia pensar numa construção simples de um loop em MIPS?
16
Mais ainda:
•
•
Instrução
Significado
add $s1,$s2,$s3
sub $s1,$s2,$s3
lw $s1,100($s2)
sw $s1,100($s2)
bne $s4,$s5,L
beq $s4,$s5,L
j L
$s1 = $s2 + $s3
$s1 = $s2 – $s3
$s1 = Memory[$s2+100]
Memory[$s2+100] = $s1
Prox. instr. label L se $s4 != $s5
Prox. instr. label L se $s4 == $s5
Prox. instr. label L
Formatos:
R
op
rs
rt
I,J*
op
rs
rt
J
op
rd
shamt
funct
endereço 16 bit ou imediato
endereço de 26 bits
J* = desvio condicional
17
Controle do Fluxo
•
Temos: beq, bne
•
E se quisermos uma nova instrução do tipo branch-if-less-than?
slt $t0,$s1,$s2
if $s1 < $s2 then
$t0 = 1
else
$t0 = 0
Usando beq, bne e $t0 pode se implementar a “lógica requerida”
•
A Instrução pode ser usada para construir "blt $s1,$s2,Label"
— é possível se construir estruturas de controle genéricas
•
Note que o montador necessita de um registrador para fazer isso
— existem políticas de uso específicas para os registradores
18
Convenções e Política de Uso dos 32
Registradores MIPS
Nome
$zero
$v0-$v1
$a0-$a3
$t0-$t7
$s0-$s7
$t8-$t9
$gp
$sp
$fp
$ra
No.Registrador
0
2-3
4-7
8-15
16-23
24-25
28
29
30
31
Uso
valor constante 0
valores para resultados e avaliação de expressões
argumentos
temporários
salvos/armazenados
mais temporários
ponteiro global
ponteiro de pilha (stack pointer)
ponteiro de quadro (frame pointer)
endereço de retorno
OBS: Registro 1, chamado $at, é reservado para o montador. Os registros 26
e 27, chamados $k0 e $k1, são reservados para o Sistema Operacional
19
Constantes
•
Constantes pequenas são usadas frequentemente...
Ex:
A = A + 5;
B = B + 1;
C = C - 18;
•
Soluções?
– Colocar “constantes típicas” na memória e carregá-las.
– Criar registradores hard-wired para certas constantes: ex. $zero
•
Instruções MIPS para imediatos:
addi $29, $29, 4
slti $8, $18, 10
andi $29, $29, 6
ori $29, $29, 4
•
Como podemos fazer isso?
– Lembram-se da instrução muli do 1º exemplo (swap)
20
O que fazer com “grandes” constantes?
•
•
É possível carregar constantes de 32 bits em um registrador
Devem ser usadas 2 instruções para implementar isso:
1. Nova Instrução “load upper immediate”
lui $t0, 1010101010101010
1010101010101010
preenchida com zeros
0000000000000000
2. Depois, completar os bits de ordem mais baixa à direita, i.e.,
ori $t0, $t0, 1110101010101010
1010101010101010
0000000000000000
0000000000000000
1110101010101010
1010101010101010
1110101010101010
ori
21
Linguagem Assembly x Linguagem de Máquina
•
•
Assembly proporciona uma representação simbólica conveniente
– MUITO MAIS FÁCIL que escrever dígitos binários
– Ex: registrador destino é sempre o primeiro
Linguagem de Máquina está em outro nível de abstração
– Ex: destino não é preenchido primeiro na instrução tipo-R
•
Assembly disponibiliza apenas “pseudoinstruções”
– ex., “move $t0,$t1” existe somente em Assembly
– Poderia ser implementado usando “add $t0,$t1,$zero”
•
Quando se considera desempenho, deve-se pensar em “contar
instruções reais” em linguagem de máquina
22
Uso das instruções
23
Uso das instruções
24
Outras questões
•
Coisas que não estão sendo cobertas aqui:
– Suporte a procedures
– Carregadores (loaders), ligadores (linkers,), pilhas (stacks),
frames, recursão, etc.
– Manipulação de strings e ponteiros
– Interrupções e exceções
– Chamadas de sistema (system calls)
•
Alguns desses pontos serão tratados no futuro e em outros cursos
•
O foco agora está em questões ligadas à arquitetura:
– Básico da linguagem de máquina MIPS e código de máquina
– Construção de um processor para executar estas instruções.
25
Sumarização: Conjunto de Instruções MIPS
26
Visão Geral do MIPS
•
•
•
•
•
Instruções simples, todas com largura de 32 bits
Bastante estruturada, pouca “carga” desnecessária nas instruções
Somente 3 formatos de instrução
R
op
rs
rt
rd
I
op
rs
rt
16 bit address
J
op
shamt
funct
26 bit address
Apostar no compilador para obter desempenho
— Quais são os objetivos de um compilador?
Ajudar o compilador “no que nós queremos”...
27
Papel fundamental do Compilador
Sem otimizações
28
Endereços em Desvios (Branches) e Saltos (Jumps)
•
•
•
Instruções:
bne $t4,$t5,Label
beq $t4,$t5,Label
j Label
Prox Instr. está em Label se $t4$t5
Prox Instr. está em Label se $t4=$t5
Prox Instr. está em Label
Formatos:
I
op
J
op
rs
rt
16 bit address
26 bit address
Endereços não estão em 32 bits
— Como manipular isso para Instruções load e store?
29
Endereços em Desvios (Branches)
•
•
Instruções:
bne $t4,$t5,Label
beq $t4,$t5,Label
Prox Instr. está em Label se $t4$t5
Prox Instr. está em Label se $t4=$t5
Formatos:
I
op
rs
rt
16 bit address
•
Pode especificar um registrador (lw e sw) e adicioná-lo a um endereço
•
– Usar o Registrador de Endereço de Instrução (PC = program counter)
– 16 bits parece pouco, entretanto muitos desvios são “próximos”
(princípio da localidade)
Instruções Jump usam apenas os bits de mais alta ordem do PC
– Endereços limitados a 256 MB (pense no porquê...)
30
Sumário: Registradores MIPS
Nome
Exemplo
$s0-$s7, $t0-$t9, $zero,
32 registradores $a0-$a3, $v0-$v1, $gp,
$fp, $sp, $ra, $at
Memory[0],
30
2
memory
words
Memory[4], ...,
Memory[4294967292]
Comentários
Localizações rápidas de dados. No MIPS, os dados devem estar nos registradores
aritméticos. O Registrador $zero no MIPS é sempre igual a 0. Registrador $at é
reservado para o montador manipular constantes grandes.
Acessado somento por instruções de transferência de dados. MIPS usa endereços
de bytes, e palavras sequenciais diferenciam de 4.
Memória armazena estruturas de dados, como vetores, e registros encadeados,
como aqueles salvos em procedure calls.
31
Sumário: Assembly MIPS
Categoria
Arim ética
Transf. de
dados
add
subtract
Linguagem Assembly MIPS
Exemplo
Significado
add $s1, $s2, $s3
$s1 = $s2 + $s3
sub $s1, $s2, $s3
$s1 = $s2 - $s3
3 operandos; dados em registradores
3 operandos; dados em registradores
add immediate
addi $s1, $s2, 100 $s1 = $s2 + 100
Usado para adicionar constantes
load w ord
store w ord
load byte
store byte
load upper
immediate
lw
sw
lb
sb
Palavra da memória para registrador
Palavra do registrador para memória
Byte da memória para registrador
Byte do registrador para memória
Carregar constante no 16 bits
superiores
branch on equal
beq
Instrução
$s1,
$s1,
$s1,
$s1,
100($s2)
100($s2)
100($s2)
100($s2)
lui $s1, 100
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
$s1 = Memory[$s2 + 100]
Memory[$s2 + 100] = $s1
$s1 = 100 * 2 16
if ($s1 == $s2) go to
PC + 4 + 100
if ($s1 != $s2) go to
$s1, $s2, 25
PC + 4 + 100
if ($s2 < $s3) $s1 = 1;
$s1, $s2, $s3
else $s1 = 0
$s1, $s2, 25
Comentário
Teste de igualdade; desvio PC-relativo
Teste de Desigualdade; desvio PCrelativo
Desvio
branch on not equal bne
Condicional
set on less than
slt
set less than
immediate
jump
slti $s1, $s2,
100
j
2500
if ($s2 < 100) $s1 = 1;
else $s1 = 0
Constante na comparação menor que
go to 10000
Saltar para o endereço alvo
jump register
jr
$ra
go to $ra
Para escolha, retorno de procedimento
jal
2500
$ra = PC + 4; go to 10000
Para chamada de procedimento
Desvio
Incondicional jump and link
Comparar menor que; para beq, bne
32
Mais detalhes sobre formas de endereçamento MIPS
1. Immediate addressing
op
rs
rt
Immediate
2. Register addressing
op
rs
rt
rd
...
funct
Registers
Register
3. Base addressing
op
rs
rt
Memory
Address
+
Register
Byte
Halfword
Word
4. PC-relative addressing
op
rs
rt
Memory
Address
PC
+
Word
33
op
rs
rt
Memory
Address
Detalhes sobre formas de
+ endereçamento
Byte
Register
Halfword
Word
4. PC-relative addressing
op
rs
rt
Memory
Address
PC
+
Word
5. Pseudodirect addressing
op
Address
PC
Memory
Word
34
Arquiteturas Alternativas
•
Projetos alternativos:
– Prover operações mais poderosas
– Objetivo: reduzir o número de Instruções executadas
– Perigo é aumentar o tempo de ciclo e/ou aumentar o CPI
•
Algumas vezes associado ao confronto “RISC x CISC”
– Virtualmente, todos os Conjuntos de Instruções de 1982 a 95 foram RISC
– VAX: minimizar o tamanho do código, de forma a tornar a linguagem
assembly mais fácil
Instruções de tamanho 1 a 54 bytes!
Para que assembly mais fácil?
•
Rapidamente, olhar as arquiteturas PowerPC e 80x86 (detalhes no livro do
Sttalings)
35
PowerPC
•
Endereçamento Indexado
– Ex:
lw $t1,$a0+$s3
#$t1=Memory[$a0+$s3]
– Como isso seria feito no MIPS?
•
•
Atualizar endereçamento
– Atualizar um registrador como parte da carga (para andar através
de arrays)
– Ex: lwu $t0,4($s3) #$t0=Memory[$s3+4];$s3=$s3+4
– Como isso seria feito no MIPS?
Outros:
– Múltiplos load/store
– Um registrador contador especial “bc Loop”
decrementa contador, se != 0 goto loop
36
80x86
•
•
•
•
•
•
1978: O Intel 8086 é anunciado (arquitetura 16 bit)
1980: O coprocessador 8087 floating point é adicionado
1982: O 80286 amplia o espaço de endereçamento para 24 bits, +
Instruções
1985: O 80386 estende para 32 bits, novos modos de endereçamento
1989-1995: O 80486, Pentium, Pentium Pro adicionam poucas
Instruções
(maioria delas projetadas para ganho de desempenho)
1997: MMX é adicionado
“This history illustrates the impact of the “golden handcuffs” of compatibility
adding new features as someone might add clothing to a packed bag an architecture that
is difficult to explain and impossible to love” (Hennessy & Patterson)
37
A arquitetura dominante: 80x86
•
•
•
Leia o livro texto para uma descrição mais detalhada
Complexidade:
– Instruções com tamanho de 1 a 17 bytes
– 1 operando pode funcionar como fonte e destino
– 1 operando pode vir da memória
– Modos de endereçamento complexos
Ex: índice de base ou de escala com deslocamento de 8 ou 32 bits
Pontos interessantes:
– As instruções mais frequentemente usadas não são tão difíceis
de construir
– Compiladores evitam porções da arquitetura que são lentas
“what the 80x86 lacks in style is made up in quantity, making it beautiful from
the right perspective” (Hennessy & Patterson)
38
Sumário
•
•
•
Complexidade da Instrução é apenas UMA das variáveis
– Número de instruções mais baixo vs. alto CPI / taxa de clock
mais baixa
Princípios de projeto:
– Simplicidade favorece regularidade
– Quanto menor, mais rápido
– Um bom projeto implica em compromisso
– Fazer o caso comum mais rápido
Conjunto de Instruções da Arquitetura (Instruction Set Architecture)
– Uma abstração MUITO importante!
39