Instruções de linguagem de máquina

Sistemas de Computação
Instruções
Instruções de
de Linguagem
Linguagem de
de Máquina
Máquina
Linguagem de montagem do
processador MIPS
Sistemas de Computação
• Operações aritméticas
Instrução
Exemplo
Significado
soma
add a, b, c a = b + c
subtração
sub a, b, c
a=b-c
Compilação de dois comandos em C
para MIPS
Sistemas de Computação
Segmento do
Programa em C
Segmento do
Programa em MIPS
a = b + c;
d = a – e;
add a, b, c
sub d, a, e
f = (g + h) – (i + j);
add t0, g, h
add t1, i, j
sub f, t0, t1
Compilação de dois comandos em C
para MIPS
Sistemas de Computação
• Operandos aritméticos localizados em
registradores
Segmento do Programa
em C
Segmento do
Programa em MIPS
a = b + c;
d = a – e;
add $s0, $s1, $s2
sub $s3, $s0, $s4
f = (g + h) – (i + j);
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
Instruções para transferência de dados
entre memória e registradores
Sistemas de Computação
• Estruturas de dados mais complexas podem
conter mais dados que o número de registradores
• Dados armazenados na memória têm que ser
transferidos para registradores para operações
aritméticas
• As instruções de transferência de dados devem
fornecer o endereço na memória do dado a ser
acessado
Instruções para transferência de dados
entre memória e registradores
Sistemas de Computação
3
100
2
10
1
101
0
1
Endereço
Processador
Dados
Memória
• Instrução para transferir dado da memória para
registrador: load word (lw)
• Instrução para transferir dado do registrador
para memória: store word (sw)
Instruções para transferência de dados
entre memória e registradores
Sistemas de Computação
• Endereço base armazenado em registrador da
instrução
• Endereço da memória formado pelo deslocamento
adicionado ao conteúdo do registrador base
Segmento do programa em C Segmento do programa em MIPS
g=h+A[8]
lw $t0,8($s3)
add $s1, $s2, $t0
Endereços reais em MIPS
Sistemas de Computação
12
100
8
10
4
101
0
1
Endereço
Processador
Dados
Memória
•
Endereços se referem a bytes
•
Na arquitetura MIPS a palavra é de 32 bits (4 bytes),
fazendo com que endereços das palavras difiram por 4.
•
Em MIPS endereços das palavras devem sempre começar
em múltiplos de 4 (restrição de alinhamento)
Instruções para transferência de dados
entre memória e registradores
Sistemas de Computação
• Endereço base armazenado em registrador da
instrução
• Endereço da memória formado pelo deslocamento
adicionado ao conteúdo do registrador base
Segmento do programa em C Segmento do programa em MIPS
A[12]=h+A[8]
lw $t0,32($s3)
add $t0, $s2, $t0
sw $t0,48($s3)
Representação das instruções do tipo R
Sistemas de Computação
• Cada instrução da linguagem de montagem é
traduzida para a linguagem de máquina expressa
de forma binária
• Campos das instruções de máquina MIPS:
op
6 bits
rd rs
5 bits
rt
5 bits
rd
shamt
5 bits
5 bits
op: código de operação
rs: registrador com primeiro operando fonte
rt: registrador com segundo operando fonte
rd: registrador que guarda resultado da operação
shamt: deslocamento
funct: código de função
funct
6 bits
Representação das instruções do tipo R
Sistemas de Computação
• Tradução de uma instrução de registrador na
linguagem de montagem para linguagem de
máquina
• add $t0, $s1, $s2
0
op
000000
6 bits
rd 17
18
8
0
32
rs
rt
rd
shamt
funct
rd
10001
10010
01000
00000
100000
5 bits
5 bits
5 bits
5 bits
6 bits
Instruções do tipo R
Sistemas de Computação
• Operações aritméticas:
– add rd, rs, rt
– sub rd, rs, rt
• Operações lógicas:
– and rd, rs,rt
– or rd, rs, rt
– sll rd, rt, shamt
– sra rd, rt, shamt
– srl rd, rt, shamt
– xor rd, rs, rt
Representação das instruções do tipo I
Sistemas de Computação
• Tradução de uma instrução de memória na
linguagem de montagem para linguagem de
máquina
• lw $t0, 1200($t1)
35
op
100011
6 bits
rd 9
rs
rd
01001
5 bits
8
rt
0100
5 bits
1200
endereço
0000 0100 1011 0000
16 bits
Representação das instruções de desvio
Sistemas de Computação
• Instrução de desvio
– beq registrador1, registrador2, L1
– bne registrador1, registrador2, L1
Segmento do programa em C
if (i==j) f = g+h;
else f=g-h;
Segmento do programa em MIPS
bne $s3, $s4, else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit:
Compilando o comando while
Sistemas de Computação
Segmento do programa em C Segmento do programa em MIPS
while (save[i] ==k)
Loop: add $t1, $s3, $s3
i = i+j;
add $t1, $t1, $t1
add $t1,$t1,$s6
lw $t0,0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:
Comando switch
Sistemas de Computação
• Permite selecionar uma entre diversas alternativas
– switch (k) {
case
case
case
case
}
0:
1:
2:
3:
f
f
f
f
=
=
=
=
i
g
g
i
+
+
-
j;
h;
h;
j;
break;
break;
break;
break;
• Pode ser implementado utilizando-se comandos ifthen-else aninhados
• Maneira mais eficiente:
– Alternativas são codificadas em uma tabela de endereços,
denominada tabela de endereços de jump
– Na execução do comando basta indexar a tabela e ir para o
endereço encontrado na tabela
– Instrução de desvio incondicional em MIPS jr
Implementação com tabela do comando
switch
Sistemas de Computação
•
Estrutura do programa
Tabela
– obtém
–
–
–
–
–
end.
na
tabela de acordo
com valor de k
vai para endereço
L0: f = i + j
L1: f = g + h
L2: f = g - h
L3: f = i - j
•
k
0
1
2
3
endereço
L0
L1
L2
L3
Código gerado para comando switch
Sistemas de Computação
# Testa se variável k entre 0 e 3
slt $t3, $s5, $zero
bne $t3, $zero, Exit
slt $t3, $s5, $t2
beq $t3, $zero, Exit
# Multiplica k por 4 para obter deslocamento na tabela
add $t1, $s5, $s5
add $t1, $t1, $t1
# Calcula o endereço correto
add $t1, $t1, $t4
lw $t0, 0($t1)
# Vai para o endereço
jr $t0
#Casos do switch
L0: add $s0, $s3, $s4
j Exit
L1: add $s0, $s1, $s2
j Exit
L2: sub $s0, $s1, $s2
j Exit
L3: sub $s0, $s3, $s4
Exit:
Modos de Endereçamento em MIPS
Sistemas de Computação
• Palavra de 32 bits
• Memória endereçada a byte
• Cada instrução tem 32 bits
• Os modos de endereçamento indicam como
encontrar os operandos das instruções
Endereçamento por registrador
Sistemas de Computação
• Indica o endereço de um registrador
6 bits 5 bits 5 bits 5 bits
op rs rt rd … funct
Registradores
Registrador
– Ex: add $s0, $t0, $t1 # $s0 = $t0 + $t1
Endereçamento base mais deslocamento
Sistemas de Computação
• Visa reduzir o tamanho das instruções e facilitar o
processo de relocação de programas
– indica o endereço de um registrador (base) e um valor relativo à
primeira instrução (deslocamento)  endereço efetivo do dado
16 bits
6 bits 5 bits 5 bits
op rs rt
Endereço
Registrador
– Ex: lw $s1, 100($s2)
Memória
+
Byte
Meiapalavra
Palavra
# $s1 = 4 bytes em Memória [$s2 + 100]
lb $s1, 100 ($s2) # coloca byte em Memória [$s2+100] nos 8
bits menos significativos de $s1 e estende o sinal
lh $s1, 100 ($s2) # coloca 2 bytes em Memória [$s2+100]
nos 16 bits menos significativos de $s1 e estende o sinal
Endereçamento imediato
Sistemas de Computação
• Constantes são utilizadas em programas para
indexar arrays, contar iterações de loops, por
exemplo
• Vários programas possuem mais de 50% de suas
operações aritméticas envolvendo constantes
• Como acessar estas constantes ?
lw
add
$t0, EndConst6($zero) # $t0 = constante 6
$s5, $s5, $t0
# soma 6 a $s5
Endereçamento imediato
Sistemas de Computação
• Valor do dado é indicado diretamente no campo
operando
• O dado é obtido junto com a instrução
6 bits
op
5 bits
rs
– Ex: addi $s5, $s5, 6
5 bits
rt
# $s5 = $s5 + 6
16 bits
imediato
Instruções aritméticas e lógicas que
utilizam endereçamento imediato
Sistemas de Computação
• addi rt, rs, imm
• andi rt, rs, imm
• ori rt, rs, imm
• xori rt, rs, imm
• slti rt, rs, imm
Endereçamento imediato
Sistemas de Computação
• Para constantes maiores que 16 bits utiliza-se a
instrução lui (load upper immediate)
• Carrega constante nos bits superiores e preenche
os inferiores com zero
– Ex: lui $t0,255
6 bits
001111
5 bits 5 bits
00000 01000
16 bits
0000 0000 1111 1111
$t0
0000 0000 1111 1111
0000 0000 0000 0000
Endereçamento imediato
Sistemas de Computação
• Qual o código em linguagem de máquina do MIPS
para carregar a constante abaixo de 32bits no
registrador $s0?
0000 0000 0011 1101 0000 1001 0000 0000
Endereçamento pseudo direto
Sistemas de Computação
• Utilizado para desvios incondicionais
– indica o endereço pela concatenação dos 26 bits da instrução com
os 4 bits mais significativos do PC para formar palavra de 32 bits
6 bits
op
26 bits
Endereço
PC
– Ex: j 10000
Memória
:
Palavra
Endereçamento relativo ao PC
Sistemas de Computação
• Utilizado para desvios condicionais
• Utilizando o campo imediato (16 bits), nenhum
programa poderia ser maior que 216
– Solução: PC= Registrador + Endereço de desvio
• Registrador utilizado é o próprio PC
– Pode desviar no intervalo PC-215 a PC+215
16 bits
6 bits 5 bits 5 bits
op rs rt
Endereço
PC
Memória
+
Palavra
– Ex: beq $s1, $s2, 25 # se ($s1 == $s2) desvia para PC + 4 + 100
# (cada instrução tem 4 bytes)
Compilando o comando while
Sistemas de Computação
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1,$t1,$s6
lw $t0,0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:
endereço
80000
80004
80008
80012
80016
80020
80024
80028
0
0
0
35
5
0
2
...
19
9
9
9
8
19
instrução
19
9
9
9
22
9
8
21
20
19
80000
0
0
0
0
8
0
32
32
32
32
Como desviar para mais longe
Sistemas de Computação
• Substitui-se a instrução beq, por bne e j
• Exemplo:
beq $s1,$s2,L1
substituído por
bne $s1, $s2, L2
j L1
L2:
Arrays e ponteiros
Sistemas de Computação
• Procedimento para zerar o conteúdo de um array
– utilizando índices de arrays
clear1(int array[], int size)
{
int i;
for (i = 0; i < size; i = i+1)
array[i] = 0;
}
– utilizando ponteiros
clear2(int *array, int size)
{
int *p;
for (p = &array[0]; p < &array[size]; p = p+1)
*p = 0;
}
Arrays e ponteiros - comparação do
código gerado
Sistemas de Computação
•
Código gerado para array
move $t0, $zero
•
Código gerado para ponteiro
move $t0, $a0
loop1: add $t1,$t0,$t0
add $t1,$a1,$a1
add $t1,$t1,$t1
add $t1,$t1,$t1
add $t2,$a0,$t1
add $t2,$a0,$t1
sw $zero,0($t2)
loop2: sw $zero,0($t0)
addi $t0,$t0,1
addi $t0,$t0,4
slt $t3,$t0,$a1
slt $t3,$t0,$t2
bne $t3,$zero,loop1
bne $t3,$zero,loop2
Arquitetura X86 - Propriedades CISC
Sistemas de Computação
• Operações aritméticas podem ler/escrever da/na
memória
• Endereçamento da memória podem envolver
cálculos complexos
– D(Rb,Ri,S)
Mem[Reg[Rb]+S*Reg[Ri]+D]
• D: deslocamento de 1,2 ou 4 bytes
• Rb: Registrador base: * possíveis registradores
• Ri: Registrador de índice: qualquer registrador
• S: Escala: 1,2, 4 ou 8