Conjunto de Instrucoes - II

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

Arquitetura do Processador e
Conjunto de Instruções (II)
EMA8996 / 2011
Alexandro Baldassin
Programa Armazenado
Instruções são armazenadas em memória
Instruções possuem endereços
usados por instruções de desvio para especificar próxima instrução a ser executada
Registrador especial armazena endereço da instrução sendo executada
PC (Program Counter)
Linguagem de Máquina
Linguagem de Montagem
descrição textual das instruções
computador “não entende” texto
Linguagem de Máquina
0’s e 1’s
Montador (assembler)
converte linguagem de montagem para linguagem de máquina
Abstrações
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
alto nível
Abstrações
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
lw	$t0, 0($2)
lw	$t1, 4($2)
sw	$t1, 0($2)
sw	$t0, 4($2)
alto nível  linguagem de montagem
linguagem de montagem
Abstrações
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
lw	$t0, 0($2)
lw	$t1, 4($2)
sw	$t1, 0($2)
sw	$t0, 4($2)
0000 1001 1100 0110 1010 1111 0101 1000
1010 1111 0101 1000 0000 1001 1100 0110
1100 0110 1010 1111 0101 1000 0000 1001
0101 1000 0000 1001 1100 0110 1010 1111
alto nível  linguagem de montagem
linguagem de montagem 
linguagem de máquina
homem
máquina
Codificação de Instruções
Como representar as instruções?
agrupar instruções com base nos operandos
definir um formato para cada tipo
Formato de instruções
tamanho fixo (RISC) x tamanho variável (CISC)
formato é dividido em campos
MIPS – Codificação
Todas instruções possuem 32 bits
Três formatos principais
Tipo-R
operandos são todos registradores
Tipo-I
um operando é imediato
Tipo-J
instruções de desvio incondicional
MIPS – Formato Tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
MIPS – Formato Tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
código da operação  op = 0 para tipo-R
MIPS – Formato Tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
registradores
registradores fonte
registrador destino
MIPS – Formato Tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
shift amount  somente usado em instruções 
 de deslocamento
Codificação Tipo-R
add	$8, $9, $10
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Codificação Tipo-R
add	$8, $9, $10
0x00
0x20
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x20
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x00
0x20
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x00
0x20
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Qual a instrução em hexadecimal?
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x00
0x20
000000
01001
01010
01000
00000
100000
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x00
0x20
000000
01001
01010
01000
00000
100000
0x0
0x2
0x0
0x4
0xA
0x2
0x1
0x0
Codificação Tipo-R
add	$8, $9, $10
0x00
0x09
0x0A
0x08
0x00
0x20
000000
01001
01010
01000
00000
100000
0x0
0x2
0x0
0x4
0xA
0x2
0x1
0x0
 0x012A4020
instrução em hexadecimal
MIPS – Formato Tipo-I
Necessário codificar o imediato na instrução
Desejável que seja consistente com tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
tipo-R
MIPS – Formato Tipo-I
Necessário codificar o imediato na instrução
Desejável que seja consistente com tipo-R
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
tipo-R
op
rs
rt
imm
6 bits
5 bits
5 bits
16 bits
tipo-I
fonte
destino
complemento de 2
[-32768, +32767]
Codificação Tipo-I
addi	$21, $22, -50
Codificação Tipo-I
addi	$21, $22, -50
0x08
0x16
0x15
0xFFCE
6 bits
5 bits
5 bits
16 bits
0x22D5FFCE
MIPS – Constantes de 32 bits
Imediatos representam valores de 16 bits 
[-32768, +32767]
Como tratar valores de 32 bits?
a = 0xABABCDCD
MIPS – Constantes de 32 bits
Imediatos representam valores de 16 bits 
[-32768, +32767]
Como tratar valores de 32 bits?
Instrução nova: lui reg, imm
load upper immediate
altera os 16 bits mais significativos da palavra
16 bits menos significativos ficam zerados
a = 0xABABCDCD
MIPS – Constantes de 32 bits
a = 0xABABCDCD
MIPS – Constantes de 32 bits
a = 0xABABCDCD
lui	$s0, 0xABAB
ori	$s0, $s0, 0xCDCD
Equivalente ao seguinte código?
MIPS – Constantes de 32 bits
a = 0xABABCDCD
lui	$s0, 0xABAB
ori	$s0, $s0, 0xCDCD
lui	$s0, 0xABAB
addi	$s0, $s0, 0xCDCD
Equivalente ao seguinte código?
MIPS – Constantes de 32 bits
a = 0xABABCDCD
lui	$s0, 0xABAB
ori	$s0, $s0, 0xCDCD
lui	$s0, 0xABAB
addi	$s0, $s0, 0xCDCD
NÃO!!! Por quê?
Imediatos em Desvios Condicionais
Se imediato representasse endereço efetivo, somente uma pequena parte da memória seria endereçável
Solução
endereçamento relativo ao PC
imediato é somado ao valor do PC
possível saltar 215 bytes a partir da posição atual
Como melhorar?
Imediatos em Desvios Condicionais
No MIPS instruções são palavras (32 bits), logo são alinhadas em 4 bytes
representar imediatos como palavras ao invés de bytes
possível saltar 215 palavras a partir do PC (217 bytes)
Cálculo do endereço
Se salto não é tomado
Se salto é tomado
PC = PC + 4
PC = (PC + 4) + (imediato*4)
Codificação de Desvios Condicionais
op
rs
rt
endereço (imm)
tipo-I
LOOP:
	beq	$t1, $zero, FIM	
	addi	$s1, $s1, 2 	
	addi	$s0, $t1, 1 	
	j	LOOP
FIM:
Codificação de Desvios Condicionais
op
rs
rt
endereço (imm)
tipo-I
LOOP:
	beq	$t1, $zero, FIM	
	addi	$s1, $s1, 2 	
	addi	$s0, $t1, 1 	
	j	LOOP
FIM:
0x04
0x09
0x00
?????
Codificação de Desvios Condicionais
op
rs
rt
endereço (imm)
tipo-I
LOOP:
	beq	$t1, $zero, FIM	
	addi	$s1, $s1, 2 	
	addi	$s0, $t1, 1 	
	j	LOOP
FIM:
0x04
0x09
0x00
0x03
Endereçamento Relativo ao PC
Se movermos o código de posição, o valor do imediato em uma instrução de salto condicional precisa ser alterado?
Endereçamento Relativo ao PC
Se movermos o código de posição, o valor do imediato em uma instrução de salto condicional precisa ser alterado?
não (PIC – Position Independent Code)
E se o destino do salto estiver além de 215 instruções?
Endereçamento Relativo ao PC
Se movermos o código de posição, o valor do imediato em uma instrução de salto condicional precisa ser alterado?
não (PIC – Position Independent Code)
E se o destino do salto estiver além de 215 instruções?
reorganizar o código e usar salto incondicional
MIPS – Formato Tipo-J
Idealmente, gostaríamos de poder saltar para qualquer lugar na memória (30 bits)
Necessário campo para código da operação (op)
op
endereço
tipo-J
6 bits
26 bits
MIPS – Formato Tipo-J
Idealmente, gostaríamos de poder saltar para qualquer lugar na memória (30 bits)
Necessário campo para código da operação (op)
Operando especifica 28 bits do endereço. E os 4 bits restantes?
op
endereço
tipo-J
226 palavras = 256 MB
Cálculo do endereço efetivo
Atenção!
endereço dado pelo operando em uma instrução de salto incondicional é absoluto (ao contrário dos saltos condicionais, onde o endereço é relativo ao PC)
4 bits
26 bits
endereço efetivo
00
4 bits mais significantes de PC+4
operando
alinhado em palavras
Saltos Incondicionais
Instrução j permite uma faixa de endereçamento de 226 palavras
Ok para 99.99999% dos casos, mas ...
E se precisar saltar para uma faixa de endereço além da permitida por j?
Usar instrução jr $reg
código salta para endereço especificado pelo registrador
Codificação de Instruções
Transforme para linguagem de máquina assumindo que code corresponda ao endereço 0x00080000
code:	addi $t0, $t0, 2
laco:
	slt $t1, $t0, $s0
	bne $t1, $zero, exit
	# 3 outras instrucoes aqui	
	j laco
exit:
	
Codificação de Instruções
Transforme para linguagem de máquina assumindo que code corresponda ao endereço 0x00080000
code:	addi $t0, $t0, 2
laco:
	slt $t1, $t0, $s0
	bne $t1, $zero, exit
	# 3 outras instrucoes aqui	
	j laco
exit:
	
addi 	$t0, $t0, 2	
op = 0x8	 rs =0x8	 rt = 0x8 imm = 0x2	 [0x8|0x8|0x8|0x2]
001000	 01000 01000 00....10
0x21080002
0x21080002
Codificação de Instruções
Transforme para linguagem de máquina assumindo
que code corresponda ao endereço 0x00080000
code:	addi $t0, $t0, 2
laco:
	slt $t1, $t0, $s0
	bne $t1, $zero, exit
	# 3 outras instrucoes aqui	
	j laco
exit:
	
slt 	$t1, $t0, $s0
op = 0x0	 rs =0x8 rt = 0x10 rd = 0x9 shamt = 0 funct = 0x2A	 
						[0x0|0x8|0x10|0x9|0x2A]
000000	 01000 10000 01001 00000 101010
0x0110482A
0x21080002
0x0110482A
Codificação de Instruções
Transforme para linguagem de máquina assumindo que code corresponda ao endereço 0x00080000
code:	addi $t0, $t0, 2
laco:
	slt $t1, $t0, $s0
	bne $t1, $zero, exit
	# 3 outras instrucoes aqui	
	j laco
exit:
	
bne 	$t1, $zero, exit
op = 0x5	 rs =0x9 rt = 0x0 imm = 0x4	 [0x5|0x9|0x0|0x4]
000101	 01001 00000 00..100
0x15200004
0x21080002
0x0110482A
0x15200004
Codificação de Instruções
Transforme para linguagem de máquina assumindo que code corresponda ao endereço 0x00080000
code:	addi $t0, $t0, 2
laco:
	slt $t1, $t0, $s0
	bne $t1, $zero, exit
	# 3 outras instrucoes aqui	
	j laco
exit:
	
j	laco
op = 0x2	 imm = 0x20001	 [0x2|0x20001]
000010	 00 0000 0010 0000 0000 0000 0001
0x08020001
0x21080002
0x0110482A
0x15200004
0x08020001
Resumo – Formatos MIPS
op
rs
rt
rd
shamt
funct
6 bits
5 bits
5 bits
5 bits
5 bits
6 bits
tipo-R
op
rs
rt
imm/endereço
6 bits
5 bits
5 bits
16 bits
tipo-I
op
endereço
tipo-J
6 bits
26 bits
Modos de Endereçamento
Definem a forma como os operandos são identificados
MIPS
registrador
imediato
base
relativo ao PC
pseudo-direto
Modos de Endereçamento
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
51
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Olhar o campo opcode para distinguir entre os formatos R, I e J
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
52
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Olhar o campo opcode para distinguir entre os formatos R, I e J
Usar o formato para determinar quais campos existem
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
53
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Olhar o campo opcode para distinguir entre os formatos R, I e J
Usar o formato para determinar quais campos existem
Escrever a instrução MIPS, convertendo cada campo para mnemônicos, registradores e imediatos
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
54
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Olhar o campo opcode para distinguir entre os formatos R, I e J
Usar o formato para determinar quais campos existem
Escrever a instrução MIPS, convertendo cada campo para mnemônicos, registradores e imediatos
Converter o código do MIPS para linguagem C. Sempre possível?
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
55
Decodificação (disassembly)
Como transformar 1’s e 0’s para linguagem de montagem e para linguagem C ?
Para cada sequência de 32 bits ...
Olhar o campo opcode para distinguir entre os formatos R, I e J
Usar o formato para determinar quais campos existem
Escrever a instrução MIPS, convertendo cada campo para mnemônicos, registradores e imediatos
Converter o código do MIPS para linguagem C. Sempre possível?
Por que faríamos isso ?
Por quê? . Instrutivo – entender como o processador funciona em nível de microarquitetura, . Debuggers, . Engenharia reversa
56
Exemplo de Decodificação (1)
Considere as 6 instruções dadas em hexadecimal:
Primeiramente, assuma que a primeira instrução esteja no endereço 0x00400000
Próximo passo: converter para binário
1) 0x00001025
2) 0x0005402A
3) 0x11000003
4) 0x00441020
5) 0x20A5FFFF
6) 0x08100001
Exemplo de Decodificação (2)
Próximo passo: identificar opcode e formato
1) 00000000000000000001000000100101
2) 00000000000001010100000000101010
3) 00010001000000000000000000000011
4) 00000000010001000001000000100000
5) 00100000101001011111111111111111
6) 00001000000100000000000000000001
0
rs
rt
rd
shamt
funct
tipo-R
1, 4-31
rs
rt
imm/endereço
tipo-I
2 ou 3
endereço
tipo-J
MIPS -> simples, porque opcode está sempre na mesma posição
Complicado se instruções tivessem tamanhos variáveis
58
Exemplo de Decodificação (3)
Olhar o opcode (6 bits mais significativos) para determinar o formato
1) 00000000000000000001000000100101
2) 00000000000001010100000000101010
3) 00010001000000000000000000000011
4) 00000000010001000001000000100000
5) 00100000101001011111111111111111
6) 00001000000100000000000000000001
Exemplo de Decodificação (3)
Olhar o opcode (6 bits mais significativos) para determinar o formato
Próximo passo: separar os campos
1) 00000000000000000001000000100101
2) 00000000000001010100000000101010
3) 00010001000000000000000000000011
4) 00000000010001000001000000100000
5) 00100000101001011111111111111111
6) 00001000000100000000000000000001
R
R
I
R
I
J
Exemplo de Decodificação (4)
Campos são separados conforme o formato
Próximo passo: traduzir para nomes
0
0
0
2
0
37
4
8
0
+3
2
1.048.577
0
0
5
8
0
42
0
2
4
2
0
32
8
5
5
-1
Exemplo de Decodificação (5)
Solução 1:
Como melhorar?
0x00400000 or $2,$0,$0
0x00400004 slt $8,$0,$5
0x00400008 beq $8,$0,3
0x0040000c add $2,$2,$4
0x00400010 addi $5,$5,-1
0x00400014 j 0x100001
Exemplo de Decodificação (5)
Solução 1:
Como melhorar?
adicionando rótulos e nomes de registradores
0x00400000 or $2,$0,$0
0x00400004 slt $8,$0,$5
0x00400008 beq $8,$0,3
0x0040000c add $2,$2,$4
0x00400010 addi $5,$5,-1
0x00400014 j 0x100001
Exemplo de Decodificação (6)
Solução mais elegante
Próximo passo: traduzir para ‘C’
necessário criatividade!!!
	or $v0,$0,$0
Loop: slt $t0,$0,$a1
	beq $t0,$0,Exit
	add $v0,$v0,$a0
	addi $a1,$a1,-1
	j Loop
Exit:
Exemplo de Decodificação (7)
$v0: produto
$a0: multiplicando
$a1: multiplicador
product = 0;
while (multiplier > 0) {
	product += multiplicand;
	multiplier -= 1;
}