Linguagem de Máquina e Procedimentos

Prévia do material em texto

1
Organização de Computadores I
DCC006
Prof. Omar Paranaiba Vilela Neto
Aula 4 – Linguagem de Máquina 
(Instruções) - Continuação
2
Procedimento ou Função
 Procedimentos: Conjunto de instruções 
com função definida
 Realizam uma série de operações como
base em valores de parâmetros
 Podem retornar valores computados
3
Procedimento ou Função
 Motivos para o uso de procedimentos:
 Tornar o programa mais fácil de ser entendido
 Permitir a reutilização do código do procedimento
 Permitir que o programador se concentre em uma parte do 
código (os parâmetros funcionam como barreira)
4
Procedimento ou Função
Etapas para execução de um procedimento
1 - Colocar parâmetros em um lugar onde o procedimento pode acessar;
2 - Transferir o controle para o procedimento
3 - Adquirir os recursos de armazenamento necessários para o procedimento
4 - Realizar a tarefa desejada
5 - Colocar o valor de retorno em um local onde o programa que chamou o 
procedimento possa acessá-lo
6 - Retornar o controle para o ponto de origem. Um procedimento pode ser chamado 
por vários pontos em um programa. 
5
Procedimento ou Função
Registradores de procedimento
 $a0-$a3: registradores de argumento – passa os parâmetros;
 $v0-$v1: registradores de valor – valores de retorno;
 $ra: registrador de endereço de retorno – retorna ao ponto de origem;
 PC: contador de programa – guarda o endereço da instrução executada.
Instruções de procedimento
 jal EndereçoProcedimento
 Pula para o procedimento e coloca o endereço de retorno em $ra
 $ra = PC + 4
 jr $ra
 Volta para endereço armazenado em $ra
6
Procedimento ou Função
Procedimento
$a0
$a1
$a2
$a3
$v0
$v1
$4
$5
$6
$7
$2
$3
7
Procedimento ou Função
O que fazer se um procedimento precisar de mais 
registradores?
Algumas opções:
 $t0-$t9: registradores temporários não preservados;
 $s0-$s7: registradores salvos que precisam ser preservados.
Onde preservar os resgistradores salvos?
Em uma pilha na memória
 
 $sp: stack pointer – apontador de pilha.
8
Pilha
$sp
Registrador usado para guardar o endereço do 
topo da pilha da chamada de procedimentos
Indica:
a posição de memória que contêm os valores 
dos registradores salvos na memória pela 
última chamada
a posição a partir da qual a próxima chamada 
de procedimento pode salvar seus 
registradores
A pilha cresce do endereço mais alto 
para o mais baixo
9
Pilha
Para todo programa, o sistema 
operacional aloca três segmentos de 
memória:
Segmento de texto: armazena 
o código de máquina Código
Pilha
Dados
Memória Principal
Segmento de pilha: local onde são 
passados parâmetros, alocado espaço 
para variáveis locais e armazenados 
endereços de retorno para chamadas de 
funções aninhadas/recursivas
Segmento de dados: alocado 
para constantes e variáveis 
globais
10
Procedimento ou Função
Exemplo
int folha (int g, int h, int i, int j)
{
int f;
f = (g+h) – (i+j);
return f
}
folha: addi $sp, $sp, -12
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw $s0, 0($sp)
lw $t0, 4($sp)
lw $t1, 8($sp)
addi $sp, $sp, 12
jr $ra
11
Procedimento ou Função
Situação da pilha
12
Exemplo – Chama de procedimento – Recursivo
int fact (int n)
{
if (n < 1) return (1);
else return (n * fact(n-1));
}
fact: addi $sp, $sp, -8
sw $ra, 4($sp)
sw $a0, 0($sp)
slti $t0, $a0, 1
beq $t0, $zero, L1
addi $v0, $zero, 1
addi $sp, $sp, 8
jr $ra
L1: addi $a0, $ao, -1
jal fact
lw $a0, 0($sp)
lw $ra, 4($sp)
addi $sp, $sp, 8
Mul $v0, $a0, $v0
jr $ra
Procedimento ou Função
13
Byte Halfword Word
Registers
Memory
Memory
Word
Memory
Word
Register
Register
1. Immediate addressing
2. Register addressing
3. Base addressing
4. PC-relative addressing
5. Pseudodirect addressing
op rs rt
op rs rt
op rs rt
op
op
rs rt
Address
Address
Address
rd . . . funct
Immediate
PC
PC
+
+
Endereçamento:
addi
add
lw
bne
j
14
clear1 (int array[], int size)
{
int i;
for (i=0; i < size; i +=1);
array[i] = 0;
}
 add $t0, $zero, $zero
loop: sll $t1, $t0, 2
 add $t2, $a0, $t1
sw $zero, 0($t2)
addi $t0, $t0, 1
slt $t3, $t0, $a1
 bne $t3, $zero, loop
Programa usando Arrays
15
clear2 (int *array, int size)
{
 int *p;
 for (p = &array[0]; p <
 &array[size]; p = p + 1);
 *p = 0;
}
Programa usando Ponteiros
 add $t0, $a0, $zero
 sll $t1, $a1, 2
 add $t2, $a0, $t1
loop: sw $zero, 0($t0)
addi $t0, $t0, 4
slt $t3, $t0, $t2
 bne $t3, $zero, loop
16
Array versus Ponteiros
 add $t0, $a0, $zero
 sll $t1, $a1, 2
 add $t2, $a0, $t1
loop: sw $zero, 0($t0)
addi $t0, $t0, 4
slt $t3, $t0, $t2
 bne $t3, $zero, loop
 add $t0, $zero, $zero
loop: sll $t1, $t0, 2
 add $t2, $a0, $t1
sw $zero, 0($t2)
addi $t0, $t0, 1
slt $t3, $t0, $a1
 bne $t3, $zero, loop
Array Ponteiro
17
Como um programa é criado
18
• Alternativas de projeto:
– prover operações mais potentes
– objetivo é reduzir o número de instruções executadas
– o perigo é um tempo de ciclo lento e/ou um maior CPI
• As vezes referido como “RISC X CISC”
– todos novos conjuntos de instrução depois de 1982 são RISC
– VAX: minimiza tamanho do código e assembly fácil
instruções tem de 1 a 54 bytes de tamanho!
• PowerPC e 80x86
Alternativas de Arquiteturas
19
PowerPC
• Endereçamento Indexado 
– exemplo: lw $t1,$a0+$s3 #$t1=Memória[$a0+$s3]
– Como fazer no MIPS? 
• Atualização no endereçamento
– atualiza um registrador como parte do load (para matrizes)
– exemplo: lwu $t0,4($s3) #$t0=Memória[$s3+4];
$s3=$s3+4
– Como fazer no MIPS?
• Outras:
– load múltiplo/store múltiplo
– um contador especial “bc Loop” 
 decrementa contador, if não 0 goto loop
20
80x86
• 1978: Intel 8086 é anunciado (arquitetura 16 bit)
• 1980: 8087 coprocessador ponto flutuante é incluído
• 1982: 80286 melhora espaço de endereçamento 24 bits, +instruções
• 1985: 80386 estende para 32 bits, novos modos de endereçamento
• 1989-1995: 80486, Pentium, Pentium Pro add a few instructions
(mostly designed for higher performance)
• 1997: MMX aparece
• 1999: Pentium III
• 2001: Pentium 4
• 2003: AMD64
• 2004: Intel estende o AMD64 (EM64T)
“Esta história ilustra o impacto da manutenção da compatibilidade”
“Um arquitetura que é difícil explicar e impossível amar” 
21
Uma arquitetura dominante: 80x86
• Complexidade:
– Instruções de 1 a 17 bytes de comprimento
– um operando atua como fonte e destino
– um operando pode vir da memória
– modos complexos de endereçamento
i.e., “base ou escalar indexado com 8 ou 32 bit deslocamento”
• Integração:
– As instruções mais freqüentemente usadas não são difíceis 
integrar
22
• Complexidade da instrução é apenas uma variável
– Baixa contagem de inst. vs. alta CPI / ciclo de clock
• Princípios de Projeto:
– Simplicidade favorece regularidade
– Menor é mais rápido
– Bom projeto demanda compromisso
– Faça primeiro o caso comum (mais rápido)
• Arquitetura de conjunto de instruções
– Sem sombra de dúvida é uma abstração muito importante
Resumo
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22