02 - Linguagem de Maquina IV

Prévia do material em texto

Arquitetura e Organização de 
Computadores
Instruções: A linguagem de máquina
Parte IV
Prof. Sílvio Fernandes
UNIVERSIDADE FEDERAL RURAL DO SEMI-ÁRIDO
DEPARTAMENTO DE CIÊNCIAS EXATAS E NATURAIS
CURSO DE CIÊNCIA DA COMPUTAÇÃO
Comunicando-se com as pessoas
 A maioria dos computadores hoje utiliza bytes
de 8 bits para representar caracteres
obedecendo um padrão (como ASCII)
 MIPS oferece instruções para mover bytes
 Load byte (lb) lê um byte da memória,
colocando-o nos 8 bits mais à direita de um
registrador
 Store byte (sb) separa o byte mais à direita de
um registrador e o escreve na memória
2
Comunicando-se com as pessoas
 Sintaxe do lb e sb
 lb $t0, 0($sp) # lê byte da origem
 sb $t0, 0($gp) # escreve byte no destino
 Qual é o código correspondente no MIPS para
void strcpy(char x[], char y[]){
int i = 0;
while((x[i] = y[i]) != ‘\0’) /* copia e testa byte*/
i += 1;
}
Considere os endereços base de x e y encontrados
em $a0 e $a1, enquanto i está em $s0
3
Comunicando-se com as pessoas
strcpy:
addi $sp, $sp, -4 #ajusta pilha para mais 1 item
sw $s0, 0($sp) #salva $s0
add $s0, $zero, $zero # i = 0+0
L1: add $t1, $s0, $a1 #endereço de y[i] em $t1
lb $t2, 0($t1) # $t2 = y[i]
add $t3, $s0, $a0 #endereço de x[i] em $t3
sb $t2, 0($t3) # x[i] = y[i]
beq $t2, $zero, L2 #se y[i] == 0, vai para L2
addi $s0, $s0, 1 # i = i+1
j L1 # vai para L1
L2: lw $s0, 0($sp) # y[i] == 0; fim da string; restura $s0
addi $sp, $sp, 4 #retira 1 word da pilha
jr $ra #retorna
4
Comunicando-se com as pessoas
 MIPS possui instruções para carregar e
armazenar quantidades de 16 bits, chamadas
halfwords
 Load half (lh) lê uma halfword da memória,
colocando-a nos 16 bits mais à direita de um
registrador
 lh $t0, 0($sp) #lê halfword (16 bits) da origem
 Store half (sh) separa a halfword
correspondente aos 16 bits mais à esquerda de
um registrador e escreve na memória
 sh $t0, 0($gp) #escreve halfword (16 bits) no destino
5
Endereçamento no MIPS para
operandos e endereços de 32 bits
 Até o momento, consideramos que endereços
de memória já estariam em registradores.
Lembrem-se que cada endereço de memória
é representado por 32 bits.
 Lembrando que as instruções com constantes
(imediatas) do MIPS só trabalham com 16 bits.
 Como fazemos para carregar constate de 32
bits no registrador $s0?
6
Endereçamento no MIPS para
operandos e endereços de 32 bits
 Precisamos usar duas instruções; nova instrução
“load upper immediate”:
7
Endereçamento no MIPS para
operandos e endereços de 32 bits
 Depois, precisamos acertar os bits de ordem
inferior, por exemplo:
Endereçamento em desvios
condicionais e jumps
 Já a instrução de desvio incondicional jump
utiliza um terceiro formato de instrução (tipo j).
 Nessas instruções temos 26 bits para especificar
o local para onde desejamos desviar.
9
Endereçamento em desvios 
condicionais e jumps
 No entanto, para desvios condicionais temos 
um problema:
 Nosso campo de desvio só possui 16 bits.
 Fazendo os cálculos, 216 = 65536;
 E agora pessoal, será que no MIPS só podemos 
fazer programas de no máximo 64 kbytes?
10
Endereçamento em desvios 
condicionais e jumps
 Para evitar este problema, os processadores
trabalham com uma técnica denominada de
endereçamento relativo.
 Basicamente a ideia é associar o endereço
expresso em uma instrução condicional a um
outro elemento (registrador).
 Qual seria este registrador?
 O registrador utilizado é o PC. Lembrem-se o PC a
todo momento se atualiza, armazenando o endereço
da instrução atual, sendo executada.
 PC = Registrador + Endereço de desvio
11
Endereçamento em desvios 
condicionais e jumps
 Porque isso resolve?
 Isso resolve porque, em geral, os endereços de desvio não
ficam muito longe dos locais onde é solicitado o desvio.
 Mas e para chamada de funções? Tem algum sentido
ela ficar próxima do local do desvio? Como isso é
resolvido?
 Lembrem-se que para funções utilizamos j ou jr que
possuem um espaçamento de bits ainda maior (26 bits).
 Adicionalmente, o MIPS otimiza isso tudo. Seu
endereçamento é feito por palavras (endereçamento
alinhado), logo o espaço de endereçamento aumenta em
mais 4 vezes.
12
Endereçamento em desvios 
condicionais e jumps
 Um loop while foi compilado para o código assembly
Loop: sll $t1, $s3, 2 # $t1 = 4 * i
add $t1, $t1, $s6 # $t1 = endereço de save[i]
lw $t0, 0($t1) # $t0 = save[i]
Bne $t0, $s5, Exit #vá para exit se save[i] != k
addi $s3, $s3, 1 # i = i + 1
j Loop
Exit:
13
Endereçamento em desvios 
condicionais e jumps
 Se considerarmos que o loop inicia na posição 80000 
da memória, qual é o código de máquina do MIPS?
 A instrução bne (4ª. Linha) acrescenta 2 words ou 8 
bytes ao endereço da instrução seguinte (80016), 
especificando o destino do desvio em relação à 
instrução seguinte (8 + 80016)
 A instrução de salto na última linha utiliza o endereço 
completo (20000*4 = 80000), correspondente ao rótulo 
Loop
14
Endereçamento em desvios 
condicionais e jumps
 Desviando para um lugar mais distante
 Dada um desvio onde o reg. $s0 é igual ao reg. $s1
beq $s0, $s1, L1
 Substitui-o por um par de instruções que ofereça uma 
distância de desvio muito maior
bne $s0, $s1, L2
j L1
L2:
15
Formas de endereçamento.
 Endereçamento em Registrador
 Onde o operando é um registrador
 add e sub, por exemplo.
 Endereçamento imediato
 Onde o operando é uma constante dentro da própria instrução
 addi e subi, por exemplo.
 Endereçamento de base
 Onde o operando está no local de memória cujo endereço é a soma de um 
registrador e uma constante.
 lw, sw
 Endereçamento relativo ao PC
 Onde o endereçamento é a soma do PC e uma constante na instrução
 bne, beq, por exemplo.
 Endereçamento pseudodireto.
 Onde o endereço de jump são os 26 bits da instrução concatenados com os 
bits mais altos do PC.
 j e jr.
16
Formas de endereçamento.
17
Formato das Instruções MIPS
18
Operandos MIPS
19
Nome Exemplo Comentário
32 registradores
$s0-$s7, $t0-$t9, $zero, 
$a0-$a3, $v0-$v1, $gp, 
$fp, $sp, $ra, $at
Locais rápidos para dados. No MIPS, os dados precisam estar em 
registradores para a realização de operações aritméticas. O 
registrador $zero sempre é igual a 0. O registrador $at é reservado 
para o montador tratar de constantes grandes
230 words na 
memória
Memória[0],
Memória[4],
...
Memória[4294967292]
Acessadas apenas por instruções de transferência de dados no 
MIPS. O MIPS utiliza endereços em bytes, de modo que os endereços 
em words sequenciais diferem em 4 vezes. A memória contém 
estruturas de dados, arrays e spilled registers.
Registradores
Nome do Registrador Número Uso
$zero 0 constante 0
$at 1 reservado para o montador
$v0 2 avaliação de expressão e resultados de uma função
$v1 3 avaliação de expressão e resultados de uma função
$a0 4 argumento 1
$a1 5 argumento 2
$a2 6 argumento 3
$a3 7 argumento 4
$t0 8 temporário (não preservado pela chamada)
$t1 9 temporário (não preservado pela chamada)
$t2 10 temporário (não preservado pela chamada)
$t3 11 temporário (não preservado pela chamada)
$t4 12 temporário (não preservado pela chamada)
$t5 13 temporário (não preservado pela chamada)
$t6 14 temporário (não preservado pela chamada)
$t7 15 temporário (não preservado pela chamada)
Registradores
Nome do Registrador Número Uso
$s0 16 temporário salvo (preservado pela chamada)
$s1 17 temporário salvo (preservado pela chamada)
$s2 18 temporário salvo (preservadopela chamada)
$s3 19 temporário salvo (preservado pela chamada)
$s4 20 temporário salvo (preservado pela chamada)
$s5 21 temporário salvo (preservado pela chamada)
$s6 22 temporário salvo (preservado pela chamada)
$s7 23 temporário salvo (preservado pela chamada)
$t8 24 temporário (não preservado pela chamada)
$t9 25 temporário (não preservado pela chamada)
$k0 26 reservado para o kernel do sistema operacional
$k1 27 reservado para o kernel do sistema operacional
$gp 28 ponteiro para área global
$sp 29 stack pointer
$fp 30 frame pointer
$ra 31 endereço de retorno (usado por chamada de função)
Assembly do MIPS
22
Categoria Instrução Exemplo Significado Comentário
Aritmética
Add add $s1, $s2, $s3 $s1 = $s2+$s3 3 operandos; dados registradores
Subtract sub $s1, $s2, $s3 $s1 = $s2-$s3 3 operandos; dados registradores
Add Immediate dddi $s1, $s2, 100 $s1 = $s2+100 Usada para somar constantes
Lógica
And and $s1, $s2, $s3 $s1 = $s2 & $s3 3 operandos em reg; AND bit a bit
Or or $s1, $s2, $s3 $s1 = $s2 | $s3 3 operandos em reg; OR bit a bit
Nor nor $s1, $s2, $s3 $s1 = ~($s2 | $s3) 3 operandos em reg; NOR bit a bit
And Immediate andi $s1, $s2, 100 $s1 = $s2 & 100 AND bit a bit entre reg. e constante
Or Immediate ori $s1, $s2, 100 $s1 = $s2 | 100 OR bit a bit entre reg. e constante
Shift left logical sll $s1, $s2, 10 $s1 = $s2 << 10 Deslocamento à esquerda por const.
Shift rigth logical srl $s1, $s2, 10 $s1 = $s2 >> 10 Deslocamento à direita por const.
Transferência 
de dados
Load word lw $s1, 100($s2) $s1 = Mem[$s2+100] Dados da mem. para o registrador
Store Word sw $s1, 100($s2) Mem[$s2+100] = $s1 Dados do registrador para a mem.
Assembly do MIPS
23
Categoria Instrução Exemplo Significado Comentário
Transferência 
de dados
load half lh $s1, 100($s2) $s1 = Mem[$s2+100] Halfword da memória para registrador
store half sh $s1, 100($s2) Mem[$s2+100] = $s1 Halfword de um reg. para memória
load byte lb $s1, 100($s2) $s1 = Mem[$s2+100] Byte da memória para registrador
store byte sb $s1, 100($s2) Mem[$s2+100] = $s1 Byte de um registrador para memória
load upper
immed.
lui $s1, 100 $s1 = 100 * 216 Carrega constante nos 16 bits mais 
altos
Desvio 
Condicional
Branch on equal beq $s1, $s2, L If($s1 == $s2) go to L Testa igualdade e desvia
Branch on not
equal
bne $s1, $s2, L If($s1 != $s2) go to L Testa desigualdade e desvia
Set on less than stl $s1, $s2, $s3 If($s2 < $s3) $s1 = 1;
Else $s1 = 0
Compara menor que
Set less than
immediate
stli $s1, $s2, 100 If($s2 < 100) $s1 = 1;
Else $s1 = 0
Compara menor que constante
Desvio
incondicional
Jump j L go to L Desvia para endereço de destino
Jump register jr $ra go to $ra Para switch e retorno de 
procedimento
Jump and link jal L $ra = PC + 4
go to L
Para chamada de procedimento
Pseudo-instruções
 Alguns montadores também implementam 
pseudo-instruções, que são instruções 
fornecidas por um montador mas não 
implementadas no hardware
PseudoMIPS Nome Formato Exemplo Significado
Move move R move $t1, $t0 add $t1, $zero, $t0
Multiply mult R mult $t1, $t0 mult $t1, $t1, $t0
Load immediate li I li $t1, 100 addiu $t1, $0, 100
Branch less than blt I blt $t1, $t0, label slt $at, $t1, $t0
bne $at, $0, label
Branch less than or equal ble I ble $t1, 34, label addi $at, $0, 35
slt $at, $t1, $at
bne $at, $0, label
Branch greater than bgt I bgt $t1, $t0, label slt $at, $t0, $t1
bne $at, $0, label
Branch greater than or equal bge I bge $t1, $t0, label slt $at, $t1, $t0
bne $at, $0, label
Diretivas do Assembler
Sintaxe Efeito
.ascii str Armazena string str em memória, mas não coloca o caracter nulo no fim da 
string. 
.asciiz str Armazena string str em memória, colocando o caracter nulo no fim da string. 
.byte b1,..., bn Armazena as n quantidades de 8 bits em bytes sucessivos na memória
.data <addr> Itens subsequentes são armazenados no segmento de dados. Se o argumento 
opcional addr está presente, os itens são armazenados começando no endereço 
addr.
.global sym Declara que o símbolo sym é global e pode ser referenciado noutros ficheiros.
.half hl, ..., hn Armazena n quantidades de 16 bits em sucessivas posições de memória. 
.word w1, ...wn Armazena n quantidades de 32 bits em words sucessivas de memória. 
.space n Reserva n bytes de espaço no segmento de dados.
.text <addr> Itens subsequentes são colocados no segmento de código. Estando presente o 
argumento opcional addr, os itens são armazenados a partir do endereço addr.
25
Chamadas de Sistema
 Estes serviços podem ser executados através 
da instrução syscall.
 O código da chamada é colocado em $v0
26
Chamadas de Sistema
27
Ferramenta
 MARS(MIPS Assembler and Runtime Simulator)
 IDE para desenvolvimento de programas assembly
MIPS
 Compilação e verificação de erro sintático
 Simulação de execução
 Gratuita
 www.cs.missouristate.edu/MARS
 Manual
 http://courses.missouristate.edu/KenVollmar/MARS/C
CSC-CP%20material/MARS%20Tutorial.doc
28
Referências
 PATTERSON, D. A. ; HENNESSY, J.L. Organização 
e projeto de computadores – a interface 
hardware software. 3. ed. Editora Campus, 
2005.
 Notas de aula do Prof. André Luis Meneses
Silva
29