Baixe o app para aproveitar ainda mais
Leia os materiais offline, sem usar a internet. Além de vários outros recursos!
Material_ArqMIPS_SimuladorMARS (1)
Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original
AOC1_aula28_Exemplo2.asm
# Revisado em 24/11/2010 - Marcos Barreto
# MORAES - 23/agosto/2006
#
# Programa que calcula o fatorial de um número inteiro sem sinal.
# Chama a função fact, que faz todo o trabalho
# O argumento para fact é passado via o registrador de argumento
# $a0. fact é uma função recursiva. Ela retorna o resultado de
# seu processamento no registrador de valor $v0.
#
# main() {
# int num=3;
# int result=0;
# result = fact(num);
# }
# int fact (int n) {
# if (n<1)
# return 1;
# else
# return (n * fact (n - 1));
# }
.data
num: .word 5
result: .word 0
.text
.globl main
main: la $t0,num # Lê endereço de num em $t0
lw $a0,0($t0) # $a0 contém o número cujo fatorial deve ser calculado
addiu $sp,$sp,-4 # Aloca espaço na pilha para 1 palavra (4 bytes)
sw $ra,0($sp) # Salva o $ra no topo da pilha
jal fact # Chama a função recursiva fact(num)
# Resultado do fatorial deve retornar em $v0
lw $ra,0($sp) # Recupera o endereço de retorno
addiu $sp,$sp, 4
la $t0,result # Lê endereço da variável de resultado
sw $v0,0($t0) # Escreve resultado na variável
# The program is finished. Exit.
li $v0, 10 # system call for exit
syscall # Exit!
fact: addiu $sp,$sp,-8 # Início da função fact. Aloca 8 bytes na pilha
sw $ra,0($sp) # Salva o endereço de retorno na pilha
sw $a0,4($sp) # Salva o número cujo fatorial se quer calcular na pilha
sltiu $t0,$a0, 1 # Instrução set on less than => $t0=1 se num<1
beq $t0,$zero,rec # Se num>=1 ($t0=0), continua recursão
addiu $v0,$zero,1 # Se está no fim da recursão retorne fact(1)=1
lw $ra, 0($sp) # Recupera o endereço de retorno
addiu $sp,$sp,8 # Esvazia a pilha
jr $ra # Retorna por aqui na folha da recursão.
rec: addiu $a0 $a0,-1 # Se não está na folha da recursão, decrementa n
jal fact # Chama fact(num-1), RECURSIVAMENTE
lw $a0,4($sp) # Na volta da recursão, recupera num
lw $ra,0($sp) # recupera endereço de retorno
addiu $sp,$sp,8 # restaura a pilha
multu $v0, $a0 # multiplica fact(num-1) ($v0) por num ($a0)
# lembrar que resultado da multiplicação vai para
# registradores hi e lo. Aqui, despreza-se a parte alta
mflo $v0 # Assume-se que hi=0 e usa-se apena lo como resultado
# Assim, $v0 e lo contêm fact(num)
jr $ra # Retorna ao programa que chamou
AOC1_aula28_Exemplo1.asm
#int leaf_example (int g, int h, int i, int j )
#{
#int f;
#f = (g + h) - (i + j);
#return f;
#}
.data
F: .word 0
G: .word 10
H: .word 15
I: .word 20
J: .word 25
.text
.globl main
main: la $t0, G # le endereco de G para $t0
la $t1, H # le endereco de H para $t1
la $t2, I # le endereco de I para $t2
la $t3, J # le endereco de J para $t3
lw $a0, 0($t0) # le valor de G para $a0
lw $a1, 0($t1) # le valor de H para $a1
lw $a2, 0($t2) # le valor de I para $a2
lw $a3, 0($t3) # le valor de j para $a3
addiu $sp,$sp,-4 # Aloca espaço na pilha para 1 palavra (4 bytes)
sw $ra,0($sp) # Salva o $ra no topo da pilha
jal leaf_example # Chama a função leaf_example
lw $ra,0($sp) # Recupera o endereço de retorno
addiu $sp,$sp, 4
la $t0,F # Lê endereço da variável de resultado
sw $v0,0($t0) # Escreve resultado na variável
# The program is finished. Exit.
li $v0, 10 # system call for exit
syscall # Exit!
leaf_example: sub $sp, $sp, 12 # ajusta a pilha para abrir espaço para guardar 3 itens
sw $t1, 8($sp) # salva o conteúdo do registrador $t1 para preservá-lo
sw $t0, 4($sp) # salva o conteúdo do registrador $t0 para preservá-lo
sw $s0, 0($sp) # salva o conteúdo do registrador $s0 para preservá-lo
add $t0, $a0, $a1 # registrador $t0 contém g + h
add $t1, $a2, $a3 # registrador $t1 contém i + j
sub $s0, $t0, $t1 # f recebe $t0 - $t1, resultado final
add $v0, $s0, $zero # retorna f ( $v0 = $s0 + 0 )
lw $s0, 0($sp) # restaura o valor de $s0 para o chamador
lw $t0, 4($sp) # restaura o valor de $t0 para o chamador
lw $t1, 8($sp) # restaura o valor de $t1 para o chamador
add $sp, $sp, 12 # ajusta a pilha de modo a remover 3 itens
jr $ra # desvia de volta para o programa que chamou
AOC1_aula28.pdf
Universidade Federal de Pelotas
Instituto de Física e Matemática
Departamento de Informática
Bacharelado em Ciência da Computação
Arquitetura Arquitetura e e OrganizaOrganizaçãçãoo
de de Computadores Computadores II
Aula 28
Arquitetura do Processador MIPS: conjunto de
instruções e programação em linguagem simbólica
Prof. José Luís Güntzel
guntzel@ufpel.edu.br
www.ufpel.edu.br/~guntzel/AOC1/AOC1.html
slide 28.2 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Motivos para o uso de procedimentos:
• Tornar o programa mais fácil de ser entendido
• Permitir a reutilização do código do procedimento
• o conceito de procedimento permite que o programador se
concentre em uma parte do código (os parâmeros funcionam
como barrreira)
Suporte de Hardware para Procedimentos
slide 28.3 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Passos que o programa e o procedimento precisam executar:
1. Colocar os parâmetros em um lugar onde eles possam ser
acessados pelo procedimento
2. Transferir o controle para um procedimento
3. Garantir os recursos de memória necessários à execução do
procedimento
4. Realizar a tarefa desejada
5. Colocar o resultado em um lugar acessível ao programa que
chamou o procedimento
6. Retornar o controle para o ponto de origem
Suporte de Hardware para Procedimentos
slide 28.4 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
O Software do MIPS utiliza os seguintes registradores na
implementação de chamada de procedimento:
• $a0-$a3: quatro registradores para argumento, através dos
quais são passados parâmetros do programa para o
procedimento
Registradores adicionais são implementados na pilha (que fica
na memória), usando o apontador da pilha: $sp
• $v0-$v1: dois registradores para retorno de valores do
procedimento para o programa
• $ra: um registrador que contém o endereço para o
procedimento retornar ao ponto de origem
Suporte de Hardware para Procedimentos
slide 28.5 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Instrução jump and link: jal endereço-do-procedimento
• Desvia para um endereço e ao mesmo tempo salva o
endereço da instrução seguinte (PC+4) no registrador $ra
Instrução jump register: jr $ra
• Desvia para um endereço armazenado no registrador $ra
Suporte de Hardware para Procedimentos
slide 28.6 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Resumindo a execução de um procedimento no MIPS:
1. O programa chamador coloca os valores dos
parâmetros em $a0-$a3
2. O programa chamador usa jal X para desviar para o
procedimento que está em X
3. O procedimento executa
4. O procedimento executa armazena os resultados em
$v0-$v1
5. O procedimento retorna o controle para o programa
chamador usando jr $ra
Suporte de Hardware para Procedimentos
slide 28.7 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
int leaf_example (int g, int h, int i, int j )
{
int f;
f = (g + h) - (i + j);
return f;
}
• Vamos supor que possamos somar ou subtrair valores como 4, 8 ou
12 ao conteúdo de um dado registrador
Compilação de um Procedimento-Folha
(i.e.: um procedimento que não chama outro procedimento)
slide 28.8 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• g, h, i, j passadas como parâmetros em $a0,
$a1, $a2, $a3
• Resultado em $s0, retorna por $v0
• O código gerado pelo compilador inicia por
leaf_example
Compilação de um Procedimento-Folha
slide 28.9 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
# salva o conteúdo do registrador $t1 para preservá-lo$t1, 8($sp)sw
# ajusta a pilha para abrir espaço para guardar 3 itens$sp, $sp, 12sub
# salva o conteúdo do registrador $t0 para preservá-lo$t0, 4($sp)sw
# salva o conteúdo do registrador $s0 para preservá-lo$s0, 0($sp)sw
Suporte de Hardware para Procedimentos
• Partindo do pressuposte que os valores antigos de $s0, $t0 e $t1
precisam ser mantidos intactos…
• Primeiro, é necessário salvar na pilha os registradores $s0, $t0 e
$t1, para que possam ser usados:
Compilação de um Procedimento-Folha
slide 28.10 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Corpo do procedimento, idêntico ao exemplo da aula passada
# f recebe $t0 - $t1, resultado final$s0, $t0, $t1sub
# registrador $t1 contém i + j$t1, $a2, $a3add
# registrador $t0 contém g + h$t0, $a0, $a1add
• O valor de retorno, a ser armazenado em f, será copiado em um
dos registradores de retorno ($v0 ou $v1)
# retorna f ( $v0 ¨ $s0 + 0 )$v0, $s0, $zeroadd
Compilação de um Procedimento-Folha
slide 28.11 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Restaurando os valores do registradores que haviam sido
empilhados
• Conclusão do procedimento, desvio para o endereço de retorno:
# desvia de volta para o programa que chamou$rajr
# restaura o valor de $s0 para o chamador$s0, 0($sp)lw
# restaura o valor de $t0 para o chamador$t0, 4($sp)lw
# restaura o valor de $t1 para o chamador$t1, 8($sp)lw
# ajusta a pilha de modo a remover 3 itens$sp, $sp, 12add
Compilação de um Procedimento-Folha
slide 28.12 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Situação da Pilha…
Compilação de um Procedimento-Folha
conteúdo de $s0
conteúdo de $t0
conteúdo de $t1
$sp
antes
$sp
durante
depois da chamada
de procedimento
i-4
i-8
i-12
ends
baixos
ends
altos
i $sp i
slide 28.13 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Para evitar o salvamento/recuperação de regs. Temporários, o
software do MIPS disponibiliza duas classes de regs.:
• $t0-$t9: dez registradores temporários que não são
preservados pelo procedimento chamado
• $s0-$s7: oito registradores de salvamento (se usados, o
procedimento chamado precisa salvar seus valores e depois
restaurá-los)
Suporte de Hardware para Procedimentos
Compilação de um Procedimento-Folha
slide 28.14 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
• No exemplo anterior, as seguintes instruções podem ser
eliminadas:
Suporte de Hardware para Procedimentos
Compilação de um Procedimento-Folha
# salva o conteúdo do registrador $t1 para preservá-lo$t1, 8($sp)sw
# salva o conteúdo do registrador $t0 para preservá-lo$t0, 4($sp)sw
# restaura o valor de $t0 para o chamador$t0, 4($sp)lw
# restaura o valor de $t1 para o chamador$t1, 8($sp)lw
slide 28.15 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• O procedimento chamador coloca na pilha todos os registradores
de argumento ($a0-$a3) ou registradores temporários ($t0-$t9) que
sejam necessário após a chamada
• O procedimento chamado coloca na pilha o endereço de retorno
(armazenado em $ra) e todos os registradores de salvmento usados
por ele ($s0-$s7)
• O apontadorda pilha ($sp) é ajustado para acomodar a quantidade
de registradores colocados na pilha
• Quando do retorno, os valores dos registradores são restaurados a
partir da pilha e $sp é atualizado
Compilação de um Procedimentos Aninhados
(i.e.: um procedimento que chama outro procedimento)
slide 28.16 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
int fact(int n )
{
if (n<1) return (1);
else return (n* fact(n-1));
}
Seja a seguinte função escrita em C:
Compilação de um Procedimentos Aninhados
• Suponha que se pode somar ou subtrair constantes 1 ou 4 ao
conteúdo dos registradores
slide 28.17 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Parâmetro passado pela variável n corresponde a $a0
• O programa compilado inicia com o label do procedimento
• Depois salva $ra e $a0 na pilha
Compilação de um Procedimentos Aninhados
# salva o endereço de retorno$ra, 4($sp)sw
# ajusta a pilha para abrir espaço para receber 2 itens$sp, $sp, 8sub
# salva o argumento n$a0, 0($sp)sw
fact:
slide 28.18 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Da primeira vez que fact for chamado, a instrução sw salva um
endereço no programa que chamou fact
• As duas instruções seguintes testam se n é menor que 1, desviando
para L1 se n >=1
Compilação de um Procedimentos Aninhados
# se n >= 1, desvia para L1$t0, $zero, L1beq
# testa se n < 1$t0, $a0, 1slt
slide 28.19 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Se n <1, fact retorna o valor 1, colocando 1 no registrador de valor
(soma 1 com 0 e coloca o resultado em $v0)
• Depois, retira dois valores de registradores de salvamento da pilha
e desvia para o endereço de retorno
Compilação de um Procedimentos Aninhados
# elimina 2 itens da pilha$sp, $sp, 8add
# retorna para depois da instrução jal$rajr
# retorna o valor 1$v0, $zero, 1add
slide 28.20 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Antes de retirar os dois valores da pilha, devemos verificar se não
houve necessidade de carregar $a0 e $ra
Compilação de um Procedimentos Aninhados
L1:
# chama fact com argumento (n-1)factjal
# n>=1, o argumento recebe (n-1)$a0, $a0, 1sub
slide 28.21 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• A próxima instrução é onde fact retorna
• O endereço de retorno e os argumentos antigos são restaurados,
junto com o ponteiro para a pilha ($sp)
Compilação de um Procedimentos Aninhados
# restaura o endereço de retorno$ra, 4($sp)lw
# ajusta $sp para eliminar 2 itens$sp, $sp, 8add
# retorna de jal: restaura argumento n$a0, 0($sp)lw
slide 28.22 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
• Agora, o registrador de valor $v0 recebe o produto do argumento
antigo, $a0, e o valor corrente do registrador de valor
• Supondo que tenhamos disponível a instrução mult
Compilação de um Procedimentos Aninhados
# retorna n*fact(n-1)$v0, $a0, $v0mult
• Finalmente, fact desvia novamente para o endereço de retorno:
# retorna para o chamador$rajr
slide 28.23 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Suporte de Hardware para Procedimentos
Características dos Registradores usados em
Procedimentos
Pilha abaixo do stack pointerPilha acima do stack
pointer
Reg de retorno de valores: $v0-$v1Reg de endereço de retorno: $ra
Reg de argumento: $a0-$a3Reg stack pointer: $sp
Reg temporários: $t0-$t9Reg de salvamento: $s0-$s7
Se usados, o procedimento chamado
precisa salvar seus valores e depois
restaurá-los
Não preservados pelo procedimento
chamado
slide 28.24 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
• O uso de constantes é muito comum em diversas operações
freqüentes (p. ex., incremento, controle de laço etc)
• No código do gcc 52% das operações envolvem constantes
• No simulador elétrico Spice, 69% das operações envolvem
constantes
• Com as instruções vistas até aqui, seria preciso buscarmos
uma constante na memória:
Operandos Imediatos (Constantes)
# $t0 ¨ 4 (constante 4)$t0, addrConstant4($zero)lw
# $sp ¨ $sp + 4$sp, $sp, $t0add
slide 28.25 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
• Alternativa para reduzir número de acessos à memória:
oferecer versões de instruções aritméticas nas quais um dos
operandos é uma constante
• Restrição: a constante é mantida dentro da própria instrução
• Esta classe de instruções usa o formato I (mesmo de lw, sw,
beq e bne)
• Exemplo:
Operandos Imediatos (Constantes)
# $sp ¨ $sp + 4$sp, $sp, 4addi
• O campo reservado para a constante tem tamanho 16 bits
• O opcode desta instrução é 8
slide 28.26 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
• Operandos imediatos também são muito usados em
comparações
• Para fazer comparações com valores não zero, existe uma
versão imediata da instrução slt (slti):
Operandos Imediatos (Constantes)
# se $s2 < 10, então $t0 ¨ 1$t0, $s2, 10slti
slide 28.27 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Carga de uma constante de 32 bits em um Registrador
• Load upper immediate (lui)
• A instrução lui transfere os 16 bits do campo da constante
imediata para os 16 mais significativos do registrador
especificado,
• Os bits menos significativos são preenchido com zero
• Esta instrução equivale a multiplicar a constante por 216,
antes de carregá-la no registrador
Operandos Imediatos (Constantes)
16 bits5 bits5 bits6 bits
operando imediatort00000opcode
15 020 1625 2131 26
slide 28.28 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Carga de uma constante de 32 bits em um Registrador
Operandos Imediatos (Constantes)
0000 0000 1111 11110100000000001111$t0, 255lui
# $t0 é mapeado
no registrador 8
0000 0000 0000 00000000 0000 1111 1111
Conteúdo do
registrador $t0 (8)
após a execução
da instr. acima
slide 28.29 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Carga de uma constante de 32 bits em um Registrador
Operandos Imediatos (Constantes)
Exemplo: qual é o código na linguagem de montagem do MIPS
para se carregar a constante de 32 bist abaixo no registrador $s0?
0000 1001 0000 00000000 0000 0011 1101
1. Carregar os 16 bits mais significativos no registrador, usando a
constante 61
# 61 decimal = 0000 0000 0011 1101 binário$s0, 61lui
0000 0000 0000 00000000 0000 0011 1101
Após a execução desta instrução, o registrador $s0 contém:
slide 28.30 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Carga de uma constante de 32 bits em um Registrador
Operandos Imediatos (Constantes)
2. Adicionar ao conteúdo do registrador o valor 2.304, expresso em
decimal
# 2304 decimal = 0000 1001 0000 0000 binário$s0, $s0, 2304addi
0000 1001 0000 00000000 0000 0011 1101
Após a execução desta segunda instrução, o registrador $s0 contém:
AOC1_aula27_Exemplo5.asm
### if ( i == j)
### f = g + h;
### else
### f = f - h;
.data # definicao das variaveis e seus valores iniciais
F: .word 0
G: .word 0
H: .word 20
I: .word 2
J: .word 3
.text
.globl main
main: la $s0, F # endereço de F em $s0
la $s1, G # load address # associa endereço da variável G ao registrador $s1
la $s2, H # load address
la $s3, I # endereço de I no registrador $s3
la $s4, J # endereço de J no registrador $s4
lw $s1, 0($s1) # le valor de G em $s1
lw $s2, 0($s2) # le valor de H em $s2
lw $s3, 0($s3) # le valor de I em $s3
lw $s4, 0($s4) # le valor de J em $s4
bne $s3, $s4, Else # desvia para Else se I for diferente de J
add $s0, $s1, $s2 # f = g + h (salta essa instrução se I for diferente de J)
j Exit # desvia para Exit
Else: sub $s0, $s1, $s2 # f = f - h (salta essa instrução se I for igual a J)
Exit: li $v0,10 # system call for exit
syscall # Exit!
AOC1_aula27_Exemplo4.asm
### if( i == j) go to L1;
### f = g + h;
### L1: f = f - i;
.data # definicao das variaveis e seus valores iniciais
F: .word 0
G: .word 0
H: .word 20
I: .word 2
J: .word 3
.text
.globl main
main: la $s0, F # endereço de F em $s0
la $s1, G # load address # associa endereço da variável G ao registrador $s1
la $s2, H # load address
la $s3, I # endereço de I no registrador $s3
la $s4, J # endereço de J no registrador $s4
lw $s1, 0($s1) # le valor de G em $s1
lw $s2, 0($s2) # le valor de H em $s2
lw $s3, 0($s3) # le valor de I em $s3
lw $s4, 0($s4) # le valor de J em $s4
beq $s3, $s4, L1 # desvia para L1 se I for igual a J
add $s0, $s1, $s2 # f = g + h (não executa esta instrução se I for igual a J)
L1: sub $s0, $s0, $s3 # f = f - i (sempre é executada)
# The program is finished. Exit.
li $v0,10 # system call for exit
syscall # Exit!
AOC1_aula27_Exemplo3.asm
### g = h + A[i]
.data # definicao das variaveis e seus valores iniciais
G: .word 0
H: .word 20
A: .word 0x2 0x4 0x6 0x8 0xA 0xB 0xD 0xF 0x0 0x0 0x0 0x0 # vetor de 12 posições e respectivos valores
I: .word 0
.text
.globl main
main: la $s1, G # load address # associa endereço da variável G ao registrador $s1
la $s2, H # load address
la $s3, A # endereço base do vetor A no registrador $s3
la $s4, I # endereço de I no registrador $s4
lw $s4, 0($s4) # le valor de I em $s4
add $t1, $s4, $s4 # $t1 recebe 2 * I
add $t1, $t1, $t1 # $t1 recebe 4 * I
add $t1, $t1, $s3 # $t1 recebe A[I]
lw $t1, 0($t1) # load word (LOAD) # $t0 recebe A[I]
add $s1, $s2, $t0 # G = H + A[I]
# The program is finished. Exit.
li $v0,10 # system call for exit
syscall # Exit!
AOC1_aula27_Exemplo2.asm
# Sample MIPS program that writes to a new file.
# by Kenneth Vollmar and Pete Sanderson
.data
fout: .asciiz "testout.txt" # filename for output
buffer: .asciiz "The quick brown fox jumps over the lazy dog."
.text
###############################################################
# Open (for writing) a file that does not exist
li $v0, 13 # system call for open file
la $a0, fout # output file name
li $a1, 1 # Open for writing (flags are 0: read, 1: write)
li $a2, 0 # mode is ignored
syscall # open a file (file descriptor returned in $v0)
move $s6, $v0 # save the file descriptor
###############################################################
# Write to file just opened
li $v0, 15 # system call for write to file
move $a0, $s6 # file descriptor
la $a1, buffer # address of buffer from which to write
li $a2, 44 # hardcoded buffer length
syscall # write to file
###############################################################
# Close the file
li $v0, 16 # system call for close file
move $a0, $s6 # file descriptor to close
syscall # close file
###############################################################
AOC1_aula27_Exemplo1.asm
### f = (g + h) - (i + j);
.data # definicao das variaveis e seus valores iniciais
F: .word 0
G: .word 10
H: .word 20
I: .word 300
J: .word 15
.text
.globl main
main: la $s1,F # load address # associa endereço da variável F ao registrador $s1
la $s2,G # load address
la $s3,H # load address
la $s4,I # load address
la $s5,J # load address
lw $s2,0($s2) # load word (LOAD) # lê valor da variável G para o registrador $s2
lw $s3,0($s3) # load word (LOAD)
add $t0,$s2,$s3 # $t0 = g + h
lw $s4,0($s4) # load word (LOAD)
lw $s5,0($s5) # load word (LOAD)
add $t1,$s4,$s5 # $t1 = i + j
sub $s1, $t0, $t1 # F = (g+h) - (i+j)
# The program is finished. Exit.
li $v0,10 # system call for exit
syscall # Exit!
AOC1_aula27.pdf
Universidade Federal de Pelotas
Instituto de Física e Matemática
Departamento de Informática
Bacharelado em Ciência da Computação
Arquitetura Arquitetura e e OrganizaOrganizaçãçãoo
de de Computadores Computadores II
Aula 27
Arquitetura do Processador MIPS: conjunto de
instruções e programação em linguagem simbólica
Prof. José Luís Güntzel
guntzel@ufpel.edu.br
www.ufpel.edu.br/~guntzel/AOC1/AOC1.html
slide 27.2 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
32 registradores (de 32 bits) de propósito geral
Os registradores são designados por:
• $s0, $s1, …, $s7
– registradores que correpondem às variáveis dos programas
escritos em linguagem de alto nível (C, por exemplo)
– São mapeados nos registradores reais de número 16 a 23
• $t0, $t1…, $t7
– registradores temporários, necessários à tradução dos
programas em linguagem de alto nível em instruções do MIPS
– São mapeados nos registradores de número 8 a 16
Linguagem Simbólica
slide 27.3 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
tipo linguagem de
montagem
descrição (1) descrição (2)
R add $s1, $s2, $s3 $s1 = $s2 + $s3 adição
R sub $s1, $s2, $s3 $s1 = $s2 - $s3 subtração
R or $s1, $s2, $s3 $s1 = $s2 OR $s3 OU
R and $s1, $s2, $s3 $s1 = $s2 AND $s3 E
lw lw $s1,
offset($s2)
$s1 =
Mem[$s2+offset]
carrega
registrador s1
sw sw $s1,
offset($s2)
Mem[$s2+offset] =
$s1
armazena
registrador s1
beq beq $s1, $s2,
offset
if($s1 == $s2) go
to PC+4+offset
salto
condicional
jump j offset jump to target
address
salto
incondicional
Instruções Principais
slide 27.4 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Seja o comando C mostrado abaixo.
f = (g + h) - (i + j);
Um possível resultado da compilação deste comando para
o MIPS seria:
Linguagem Simbólica
# f recebe $t0 - $t1, resultado final$s0, $t0, $t1sub
# registrador $t1 contém i + j$t1, $s3, $s4add
# registrador $t0 contém g + h$t0, $s1, $s2add
slide 27.5 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Acesso a um operando que está na memória
Suponha que:
• A seja um array de 100 palavras,
• O compilador associa as variáveis g e h aos registradores $s1
e $s2
• O endereço inicial do array (endereço-base) está armazenado
em $s3.
Traduza o seguinte comando de atribuição, escrito em C para
a linguagem de montagem do MIPS.
g = h + A[8];
Linguagem Simbólica
slide 27.6 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
tipo linguagem de
montagem
descrição (1) descrição (2)
R add $s1, $s2, $s3 $s1 = $s2 + $s3 adição
R sub $s1, $s2, $s3 $s1 = $s2 - $s3 subtração
R or $s1, $s2, $s3 $s1 = $s2 OR $s3 OU
R and $s1, $s2, $s3 $s1 = $s2 AND $s3 E
lw lw $s1,
offset($s2)
$s1 =
Mem[$s2+offset]
carrega
registrador s1
sw sw $s1,
offset($s2)
Mem[$s2+offset] =
$s1
armazena
registrador s1
beq beq $s1, $s2,
offset
if($s1 == $s2) go
to PC+4+offset
salto
condicional
jump j offset jump to target
address
salto
incondicional
Instruções Principais
slide 27.7 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Primeiramente, é necessário transferir A[8] para um registrador:
Linguagem Simbólica
# registrador temporário $t0 recebe A[8]$t0, 8 ($s3)lw
# g recebe h + A[8]$s1, $s2, $t0add
A instrução seguinte pode operar normalmente com o valor
trazido da memória, pois ele está armazenado no registrador
temporário $t0:
slide 27.8 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
Sobre o compilador
• O Compilador é responsável por
- associar variáveis a registradores
- alocar em endereços de memória certas estruturas de dados (tais
como os arrays)
- otimizar o código gerado
• Assim, é fácil para o compilador colocar o endereço
inicial nas instruções de transferência de dados
slide 27.9 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
Endereçamento de Memória
• Quase todas as arquiteturas endereçam a memória a bytes
• O endereço de uma palavra deve ser igual ao endereço de um
de seus bytes (mas sempre o mesmo)
1018
12
4
0
endereço
1
10
100
dados
...
...
slide 27.10 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
Endereçamento de Memória
• O endereço de duas palavras consecutivas na memória se
difere sempre de 4 unidades
• O espaço de endereçamento de memória do MIPS é de 230
palavras (de 32 bits):
112
1018
4294967292
4
0
endereço
77
10
100
dados
......
slide 27.11 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
Endereçamento de Memória
• No MIPS as palavras sempre começam em endereços
múltiplos de 4 (restrição de alinhamento)
• MIPS usa o endereçamento big endian
• O endereçamento a bytes também afeta a indexação dos
arrays: a instrução lw do exemplo anterior precisa ser
# registrador temporário $t0 recebe A[8]$t0, 32 ($s3)lw
i+3
i+2
i+1
i
End.
byte0 (menos sig.)
byte1
byte2
byte3 (mais sig.)
Memória
slide 27.12 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Uso das Instruções Load e Store
• Suponha que a variável h esteja associada ao registrador $s2 e
que o endereço do array A esteja armazenado em $s3
• Qual é o código de montagem do MIPS para o seguinte
comando de atribuição, escrito em C?
A[12] = h + A[8]
Linguagem Simbólica
# h + A[8] é armazenado em A[12]$t0, 48 ($s3)sw
# registrador temporário $t0 recebe h + A[8]$t0, $s2, $t0add
# registrador temporário $t0 recebe A[8]$t0, 32 ($s3)lw
slide 27.13 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Usando uma Variável para Indexar Array
Suponha que:
• A é um array de 100 elementos, cujo endereço-base está
armazenado no registrador $s3
• O compilador associa as variáveis g, h e i aos registradores $s1,
$s2 e $s4
• Qual é o código gerado para o MIPS para o seguinte comando
de atribuição, escrito em C?
g = h + A[i]
Linguagem Simbólica
slide 27.14 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Usando uma Variável para Indexar Array
• Antes de carregar A[i] em um registrador temporário, é
preciso
conheccer seu endereço
• Antes de somar o valor de i ao endereço-base do array A, é
preciso multiplicaro o valor do índice i por 4 (endereçamento a
byte)
• Ao invés de usar a instrução mul, usar add
Linguagem Simbólica
slide 27.15 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Usando uma Variável para Indexar Array
Linguagem Simbólica
# registrador temporário $t1 recebe 4 * i$t1, $t1, $t1add
# registrador temporário $t1 recebe 2 * i$t1, $s4, $s4add
# registrador temporário $t1 recebe o endereço de A[i]$t1, $t1, $s3add
# g recebe h + A[i]$s1, $s2, $t0add
# registrador temporário $t0 recebe A[i]$t0, 0 ($t1)lw
g = h + A[i]
slide 27.16 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
• Muitos programas usam muito mais variáveis do que o
número de registradores que a máquina-alvo possui
• O compilador tenta manter nos registradores as variáveis
usadas com mais freqüência, deixando as demais na
memória (acessáveis via load/store)
• O processo de colocar na memória as variáveis menos
usadas é chamado de derramamento (spilling)
slide 27.17 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
A interface Hardware/Software
• Velocidade de acesso a um dado em:
registrador >> em memória
• Instruções aritméticas e lógicas no MIPS: fonte e destino
em registradores
• Instruções de transferência de dados: somente lê um
operando ou escreve um operando (não operada sobre
dados)
• Para obter melhor desempenho, um compilador pecisa
usar eficientemente os registradores disponíveis
slide 27.18 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Instruções de Desvio
• Usadas para instruções que envolvem tomada de decisão
(if, goto etc)
• No MIPS:
beq reg1, reg2, L1
Branch if equal: desvia para o comando com label L1, se
reg1 == reg2
bne reg1, reg2, L1
Branch if not equal: desvia para o comando com label L1, se
reg1 != reg2
slide 27.19 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Comando if em uma Instrução
de Desvio Condicional
• Seja código a seguir, escrito em linguagem C:
if( i == j) go to L1;
f = g + h;
L1: f = f - i;
• Suponha que as variáveis f, g, h, i e j sejam alocadas nos
registradores $s0, $s1, $s2, $s3 e $s4, respectivamente
• Qual seria o cógdigo gerado pelo compilador do MIPS?
slide 27.20 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Comando if em uma Instrução
de Desvio Condicional
L1:
# f = g + h (não executa esta instrução se i for igual a j)$s0, $s1, $s2add
# desvia para L1 se i for igual a j$s3, $s4, L1beq
# f = f - i (sempre é executada)$s0, $s0, $s3sub
slide 27.21 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Comando if-the-else em Desvios
Condicionais
• Usando as mesmas variáveis do exemplo anterior, obter o
código MIPS gerado para o seguinte comando em C:
if ( i == j)
f = g + h;
else
f = f - h;
slide 27.22 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Comando if em uma Instrução
de Desvio Condicional
# f = f - h (salta esta instrução se i = j )$s0, $s1, $s2subElse:
# f = g + h (salta esta instrução se i ≠ j )$s0, $s1, $s2add
Exit:
# desvia para ExitExitj
# desvia para Else se i for diferente de j (i ≠ j )$s3, $s4, Elsebne
slide 27.23 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Laços (Loops)
• Os comandos de desvio servem tanto para escolher uma
entre duas alternativas (comandos if), quanto para
controlar iterações (laços ou loops)
slide 27.24 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Laço contendo um Array com
Índice Variável
• No laço a seguir, escrito em linguagem C, suponha que
• A seja um array de 100 elementos
• O compilador associa as variáveis f, g, h, i e j aos
registradores $s0, $s1, $s2, $s3 e $s4, respectivamente
Loop: g = g + A[ i ];
i = i + j;
if ( i != h ) go to Loop;
slide 27.25 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Laço contendo um Array com
Índice Variável
# g recebe = g + A[ i ]$s1, $s1, $t0add
# i recebe = i + j$t1, $t1, $s5add
# registrador temporário $t0 recebe A[ i ]$t0, 0 ($t1)lw
# registrador temporário $t1 recebe 4* i$t1, $t1, $t1add
Loop:
# $t1 recebe o endereço de A[ i ]$t1, $t1, $s5add
# registrador temporário $t1 recebe 2 * i$t1, $s3, $s3add
# desvia para Loop se i ≠ j$s3, $s2, Loopbne
slide 27.26 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Laço While
• Em linguagem C, evita-se usar o go to
• Então, um laço normalmente encontrado em C seria
while ( save[ i ] == k )
i = i + j;
• Suponha que i, j, e k correspondam aos registradores $s3,
$s4 e $s5, respectivamente, e que o endereço-base do
array save esteja em $s6
• Qual seria o código MIPS para este laço?
slide 27.27 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Compilação de um Laço contendo um Array com
Índice Variável
# desvia para LoopLoopj
# desvia para Exit se save[ i ] ≠ k$t0, $s5, Exitbne
# i recebe = i + j$s3, $s3, $s4add
# registrador temporário $t0 recebe save[ i ]$t0, 0 ($t1)lw
# registrador temporário $t1 recebe 4* i$t1, $t1, $t1add
Exit:
Loop:
# $t1 recebe o endereço de save[ i ]$t1, $t1, $s6add
# registrador temporário $t1 recebe 2 * i$t1, $s3, $s3add
slide 27.28 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Instrução set on less than (slt)
• O testes de igualdade ou desigualdade são os mais
populares dentre todos os testes de condição
• Mas às vezes é preciso verificar se o valor de uma
variável é menor do que o de outra (exemplo, testar se
um índice é menor que zero)
• Set on less than (slt): slt reg1, reg2, reg3
• Compara reg2 com reg3,
• Se reg2 < reg3, reg1 ¨ 1
• Caso contrário, reg1 ¨ 0
slide 27.29 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Instrução set on less than (slt)
• Os compiladores para o MIPS usam as instruções slt, bne
e beq, juntamente com o valor fixo $zero (registrador
read-only $0) para criar as condições relativas:
– Igual
– Não-igual
– Menor que
– Menor ou igual a
– Maior que
– Maior ou igual a
slide 27.30 Prof. José Luís Güntzel
Arquitetura do MIPS
ComputaçãoUFPel
Arquitetura e Organização de Computadores I
Linguagem Simbólica
Instrução set on less than (slt)
• Qual é o código do MIPS para testar se uma variável a
(alocada em $s0) é menor que a variável b (alocada em
$s1) e desviar para o label Less se a condição for
verdadeira?
# desvia para Less se $t0 ≠ 0$t0, $zero, Lessbne
# reg $t0 recebe 1 $t0 < $s1 ( a < b )$t0, $s0, $s1sltCompartilhar
Materiais relacionados
7 pág.
19 pág.
Perguntas relacionadas
Compartilhar