Linguagem de Máquina

Conteú
Conteúdo
Organização e Arquitetura
de computadores
Instruções: a linguagem de máquina
Prof. Dr. Luciano José Senger
Introdução
Operações no hardware do computador
Operandos do hardware do computador
Representando instruções no computador
Operações lógicas
Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introduç
Introdução
Introduç
Introdução
• Para controlar o hardware do computador, é
necessário falar a sua linguagem
• É fácil ver, por métodos lógicos formais, que existem
certos [conjuntos de instruções] que são adequados
para controlar e causar a execução de qualquer
seqüência de operações... As considerações decisivas,
do ponto de vista atual, na seleção de um [conjunto de
instruções], são mais de natureza prática: a
simplicidade do equipamento exigido pelo [conjunto de
instruções] e a clareza de sua aplicação para os
problemas realmente importantes, junto com a
velocidade com que tratam esses problemas
• Palavras da linguagem do computador são
chamadas de instruções = vocabulário é chamado
de conjunto de instruções
• Apresentação das instruções através de uma
abordagem top-down
• Linguagens de computadores são semelhantes
(entre diferentes arquiteturas), ao contrário da
linguagem dos humanos
– Burks, Goldstine e von Neumann, 1947
Introduç
Introdução
Introduç
Introdução
• Conjunto de instruções (a ponta do iceberg)
•
• Exemplo: MIPS (http://en.wikipedia.org/wiki/MIPS_architecture)
– Conjunto de instruções criados a partir da década de 80
– 100 milhões de processadores fabricados em 2002
– ATI, Broadcom, Cisco, NEC, Nintendo, Silicon
Graphics, Sony, Texas Instruments e Toshiba
• Processador RISC (conjunto reduzido de
instruções)
–
–
–
–
Tamanho de instruções fixo (fixed instruction lengths)
Instruções de load-store (load-store instruction sets)
Modos de endereçamento limitado (limited addressing modes)
Operações limitadas (limited operations)
•
Arquiteturas de programa
armazenado
Control necessita
1. Instruções de entrada da
memória
2. Sinais para controlar o fluxo de
informação entre os
componentes do caminho de
dados
3. Sequenciamento de instruções
CPU
Memory
Control
Devices
Input
Datapath
Output
Fetch
Exec
Decode
• Datapath tem
– componentes – unidades funcionais e banco de registradores
– Interconexões - componentes que são conectados de forma que as
instruções possam ser executadas e os dados possam ser trazidos e
armazenados na memória
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introdução Operações no hardware do computador
Operandos do hardware do computador
Representando instruções no computador
Operações lógicas
Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Operaç
Operações do hardware do computador
• Todo computador precisa realizar operações
aritméticas
add a, b, c
• Instrui o computador para realizar a soma entre as
variáveis b e c e armazenar o resultado em a
• Exemplo: colocar a soma de b, c, d, e e na variável
a:
• Em linguagem de alto nível a = b + c + d + e
• Em Assembly MIPS:
add a, b, c
add a, a, d
add a, a, e
# soma b+c é colocada em a
# soma b+c+d está em a
# soma b+c+d+e está em a
Operaç
Operações do hardware do computador
Operaç
Operações do hardware do computador
• O número natural de operandos para uma
operação de adição é três
• Contra-exemplo: IA-32 (p.e. Pentium)
• Exigir que cada instrução tenha exatamente três
operações nem mais nem menos, está de acordo
com manter o hardware simples: o hardware para
um número variável de operandos é mais
complicado do que o hardware para um número
fixo:
• Compilando duas instruções de atribuição C no
MIPS:
– ADD AX,BX
a = b + c;
d = a – e;
– a tradução é realizada pelo compilador
– Em MIPS:
add a, b, c
• Princípio de projeto 1: simplicidade favorece a
regularidade
sub d, a, e
Operaç
Operações no hardware do computador
Conteú
Conteúdo
• Compilando uma instrução complexa no MIPS
•
•
•
•
•
•
•
•
•
f = (g + h) – (i + j)
• O compilador precisa desmembrar essa instrução em
várias instruções assembly, pois somente uma operação é
realizada por instrução MIPS
add t0, g, h # var. temp. t0 contém g+h
add t1, i, j # var. temp. t1 contém i+j
sub f, t0, t1 # f recebe t0 – t1
• Note que uma expressão na linguagem C gera 3 instruções
assembly para o MIPS
• Reflexão: um número maior de instruções de máquina por
expressão é melhor ou pior?
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador
Representando instruções no computador
Operações lógicas
Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Operandos no hardware do computador
• Ao contrário dos programas nas linguagens de
alto nível, os operandos das instruções aritméticas
são restritos, precisam ser de um grupo limitado
de locais especiais, embutidos diretamente no
hardware, chamados registradores (registers)
• Os registradores são os tijolos da construção do
computador – primitivas usadas no projeto do
computador e são visíveis para o programador
• O tamanho dos registrados na arquitetura MIPS é
32 bits; grupos de 32 bits ocorrem com tanta
freqüência no MIPS que recebem o nome de
palavra (word)
Operandos no hardware do computador
Name
$zero
$at
$v0 - $v1
$a0 - $a3
$t0 - $t7
$s0 - $s7
$t8 - $t9
$gp
$sp
$fp
$ra
Register
Number
0
1
2-3
4-7
8-15
16-23
24-25
28
29
30
31
Usage
Preserve
on call?
constant 0 (hardware)
n.a.
reserved for assembler
n.a.
returned values
no
arguments
yes
temporaries
no
saved values
yes
temporaries
no
global pointer
yes
stack pointer
yes
frame pointer
yes
return addr (hardware)
yes
Operandos no hardware do computador
Operandos no hardware do computador
• Uma diferença entre variáveis de um programa em
linguagem de alto nível e os registradores é que o número
de registradores é limitado
• O computador MIPS tem 32 registradores
• Princípio de projeto 2: menor significa mais rápido
• A convenção no MIPS é usar nomes com um sinal
de $ seguido de dois caracteres para representar
um registrador.
– Uma quantidade muito grande de registradores pode aumentar o tempo do
ciclo de clock simplesmente porque os sinais eletrônicos levam mais tempo
quando precisam atravessar uma distância maior
• Deve-se equilibrar o “desejo” dos programas por mais
registradores com o desejo do projetista de manter o ciclo
de clock mais rápido
• Um número maior de registradores necessita de um
número maior de bits para representação: influência no
tamanho da instrução
– $S0, $S1, $T0, $T1
• Compilando uma atribuição em C usando
registradores:
f = (g + h) – (i + j)
add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1
Operandos no hardware do computador
Operandos no hardware do computador
• Operandos na memória
• A instrução que copia dados da memória para um
registrador tradicionalmente é chamada de load
– Operações aritméticas só ocorrem com os registradores
nas instruções MIPS; assim o MIPS deve ter instruções
que transferem os dados entre o processador e a
memória: instruções de transferência de dados
– Para acessar uma word na memória, é necessário passar
o endereço de memória a ser utilizado
• O formato da instrução load é o nome da operação
seguido pelo registrador a ser carregado, depois
uma constante e o registrador usado para acessar
a memória.
• A soma da parte constante da instrução com o
conteúdo do segundo registrador forma o
endereço de memória
Operandos no hardware do computador
Operandos no hardware de computador
• Compilando uma atribuição quando um operando
está na memória
• Compilando uma atribuição quando um
– Vamos supor que A seja uma sequência de 100 words e
que o compilador tenha associado as variáveis g e h aos
registradores $s1 e $s2. Vamos supor que o endereço
inicial da seqüência esteja no endereço armazenado em
$s3 (endereço base)
g = h + A[8];
– embora haja uma única operação nessa instrução de
atribuição, um dos operandos está na memória, de
modo que precisamos transferir A[8] para um
registrador ($s3 contém elemento base) :
lw $t0, 8($s3)
#registrador temporário recebe A[8]
operando está na memória (cont.)
–
A instrução seguinte (add) pode operar sobre o valor
em $t0, já que é um registrador:
lw $t0, 8($s3)
add $s1, $s2, $t0
–
A constante na instrução é chamada de offset e o
registrador acrescentado para formar o endereço é
chamado de registrador base
Operandos no hardware do computador
Operandos no hardware do computador
• Interface hardware/software
• No MIPS, palavras precisam começar em
endereços que sejam múltiplos de 4 (restrição de
alinhamento)
– Além de associar variáveis a registradores, o compilador aloca
estrutura de dados, como vetores, em locais na memória
– Como os bytes de 8 bits são úteis em muitos programas, a maioria
das arquiteturas endereça bytes individuais
– Endereços de words combinam os endereços dos 4 bytes dentro da
palavra
• No MIPS, palavras precisam começar em endereços que
sejam múltiplos de 4
• O endereçamento em bytes afeta o índice do array:
para obter o endereço em bytes de maneira
apropriada o offset necessita ser igual a 4x8=32
• A instrução complementar ao load chama-se store;
ela copia dados de um registrador para a memória
• A instrução store é representada pelo mnemônico
sw
Operandos no hardware do computador
• Compilando com load e store
– Suponha que a variável h esteja associada ao registrador $s2 e o
endereço base do vetor A esteja armazenado em $s3. Qual código
assembly do MIPS para a instrução de atribuição C a seguir?
– A[12] = h + A[8]
– Embora seja uma instrução na linguagem C, dois operandos estão
na memória; são necessárias instruções para buscar os dois
operandos da memória:
lw $t0, 32($s3)
# reg. temp. $t0 recebe A[8]
add $t0, $s2, $t0 # reg. temp. $t0 recebe h + A[8]
sw $t0, 48($s3)
# armazena resultado em A[12]
Operandos no hardware do computador
• Interface hardware/software
– Muitos programas têm mais variáveis do que os computadores têm
registradores
– O compilador tenta manter as variáveis mais utilizadas nos
registradores e coloca as restantes na memória, usando load e store
para movimentar os dados
– O processo de colocar variáveis menos utilizadas na memória ou
aquelas que só serão empregadas mais tarde é denominado spilling
registers
– Registradores, apesar de serem mais reduzidos e terem um
tamanho menor que a memória principal, são mais rápidos: isso
define a preocupação com a utilização correta dos registradores
• Constantes ou operandos imediatos
– Muitas vezes, os valores que necessitam ser trabalhados são
passados na instrução como constantes, e não como endereços de
memória; quando os dados são passados dessa forma, como
constantes, é utilizado o modo de endereçamento imediato
Operandos no hardware do computador
Operandos no hardware do computador
• Trabalhando com constantes
– Usando apenas instruções, teríamos de ler uma
constante da memória para utilizá-la:
lw $t0, EndConstante4($s1)
add $s3, $s3, $t0
– Supondo que EndConstante4 seja o endereço de
memória para a constante 4
– Uma alternativa que evita a instrução load, e assim uma
leitura em memória, é oferecer instruções aritméticas
em que o operando seja uma constante
– Essa instrução (no caso de uma soma) é chamada de
add imediato, ou addi:
addi $s3, $s3, 4 # $s3 = $s3 + 4
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
• Trabalhando com constantes (cont.)
– Princípio de projeto 3: agilize os casos mais comuns
– Os operandos com constantes ocorrem com bastante
freqüência e, incluindo constantes dentro das instruções
aritméticas, as operações tornam-se mais rápidas para
serem executadas
Representando instruç
instruções no computador
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador
Operações lógicas
Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
• Embora quando programa-se em assembly utilizase mnemônicos (como lw, sw, add e sub), as
instruções são representadas e executadas através
de um conjunto de bits
• Além disso, como os registradores são parte de
quase todas as instruções, é preciso haver uma
convenção para mapear os nomes dos
registradores em números binários
– $s0 a $s7 são mapeados nos registradores de 16 a 23;
– $t0 a $t7 são mapeados nos registradores de 8 a 15;
• Exercício: qual é o código binário para o
registrador $s7?
Representando instruç
instruções no computador
Representando instruç
instruções no computador
• Traduzindo uma instrução assembly MIPS para
uma instrução de máquina:
add $t0, $s1, $s2
• Esse layout da instrução é chamado de formato de
instrução
• As instruções no MIPS tem todas 32 bits de tamanho
• Os campos do MIPS
0
17
18
8
0
32
• Cada um desse segmentos de uma instrução é chamado campo; o
primeiro e o último campos combinados dizem ao computador MIPS
que essa instrução realiza soma
• O segundo campo indica o número do registrador que é o primeiro
operando de origem da operação de soma (17 = $t1)
• O terceiro campo indica o outro operando de origem (18 = $t2)
• O quarto campo contém o número do registrador que receberá o
resultado (8 = $s0)
• O quinto campo não é empregado nessa instrução
op
(6 bits)
–
–
–
–
–
–
rs
(5 bits)
rt
(5 bits)
rd
(5 bits)
shamt
(5 bits)
Funct
(6 bits)
op: operação básica, tradicionalmente chamada de opcode
rs: o registrador do primeiro operando de origem
rt: o registrador do segundo operando de origem
rd: o registrador do operando de destino
shamt: shift amount; quantidade de deslocamento
funct: função; esse campo seleciona a variante específica da
operação no campo op, e as vezes, é chamado de código de função
Representando instruç
instruções no computador
Representando instruç
instruções no computador
• Problemas de endereçamento
• Formato I
– Existe um problema quando uma instrução precisa de campos
maiores do que aqueles mostrados. Por exemplo, a instrução lw
precisa especificar dois registradores e uma constante; se o
endereço tivesse apenas 5 bits do formato anterior, a constante
estaria limitada a 32 (2^5)
– Existe então um conflito entre manter entre o desejo de manter
todas as instruções com o mesmo tamanho e o desejo de ter uma
instrução único
– Princípio de Projeto 4: um bom projeto exige bons compromissos
– O compromisso escolhido pelos projetistas do MIPS é manter todas
as instruções com o mesmo tamanho, exigindo assim diferentes
formatos para os campos para diferentes tipos de instruções
– O formato anterior é chamado de tipo R (de registrador) ou
formato R.
– Um segundo tipo de formato de instrução é chamado de formato I,
utilizando pelas instruções imediatas e de transferência de dados.
Representando instruç
instruções no computador
op
(6 bits)
rs
(5 bits)
rt
(5 bits)
Constante ou endereço
(16 bits)
– O endereço de 16 bits significa que uma instrução lw pode carregar
qualquer word dentro de uma região de +/- 2^15 do endereço do
registrador base (8192 words)
– De modo semelhante, a soma imediata é limitada a constantes que
não sejam maiores do que 2^15
lw $t0, 32($s3)
– Aqui, 19 (para $s3) é colocado no campo rs, 8 (para $t0) é colocado
no campo rt e 32 é colocado no campo de endereço (veja que o
formato mudou: o campo rt especifica o registrador de destino, que
recebe o resultado do lw
Representando instruç
instruções no computador
• Traduzindo do assembly MIPS para a linguagem de máquina
– A instrução lw é representada por 35 no opcode
– Se $t1 possui a base do array A e $s2 corresponde a h:
– A[300] = h + A[300];
– É compilada para:
– O registrador base 9 ($t1) é especificado no segundo campo (rs) e o
registrador de destino 8 ($t0) é especificado no terceiro campo (rt)
– O offset para selecionar A[300] (1200=300x4) aparece no campo final
lw $t0, 1200($t1) # reg. $t0 recebe A[300]
add $t0, $s2, $t0 # reg. $t0 recebe h + A[300]
sw $t0, 1200($t1) # armazena h +A[300] na mem.
– A instrução add é especificada com opcode 0 e funct 32
– A instrução sw é identificada com 43 no opcode
– Importante: lembre-se que os valores estão representados em
decimal, mas na verdade são representados em binário.
35
9
8
0
18
8
43
9
8
1200
8
0
32
1200
Representando instruç
instruções no computador
• Por que o MIPS não tem uma instrução de
subtração imediata?
– Constantes negativas aparecem com muito menos
frequência em C e Java, e por isso não são o caso
comum e não merecem suporte especial
– Como o campo imediato mantém constantes negativas
e positivas, a soma imediata de um valor negativo é
igual a subtração imediata com um número positivo, de
modo que a subtração imediata é supérflua
35
9
8
0
18
8
43
9
8
1200
8
0
32
1200
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas
Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Operaç
Operações ló
lógicas
Operaç
Operações ló
lógicas
• Embora o projeto do primeiros computadores se
• Operações de deslocamento (shifts)
concentrasse em words completas, logo ficou claro que é
útil atuar sobre campos de bits de uma word
– Operações lógicas servem para empacotar e desempacotar grupos
de bits em words
– Movem todos os bits de uma word para esquerda ou
para direita, preenchendo com zero os bits que ficaram
vazios
– Shift left logical:
sll $t2, $s0, 4 # reg $t2 = reg $s0 << 4 bits
Operações lógicas
Operadores C
Operadores Java
Instruções MIPS
Shift a esquerda
<<
<<
Shift a direita
>>
>>
AND bit a bit
&
&
OR bit a bit
|
|
NOT bit a bit
~
~
sll
srl
and, andi
or, ori
nor
– O campo da instrução MIPS chamado de shamt (shift
amount) é usado nas instruções de deslocamento
– ssl é codificada com zeros nos campos op e funct, rd
contém $t2, rt contém $s0 e shamt contém 4
– rs não é utilizado.
0 (op)
0 (rs)
16 (rt)
Operaç
Operações ló
lógicas
Operaç
Operações ló
lógicas
• Operações de deslocamento
• Operações lógicas
– O deslocamento lógico à esquerda de i bits gera o mesmo
resultado que multiplicar por 2^i
10 (rd)
4 (shamt)
0 (funct)
– Os projetistas do MIPS decidiram incluir a instrução
NOR no lugar de NOT: se um operando for zero, a
instrução é equivalente a NOT:
• A NOR 0 = NOT (A OR 0) = NOT (A)
• Operações lógicas
nor $t0, $t1, $t3 # $t0 = ~($t1 | $t3)
– A operação AND é útil para isolar bits de uma palavra (operações
com máscara)
and $t0, $t1, $t2 # $t0 = $t1 & $t2
– Para colocar um bit em 1 em um grupo de bits, pode-se utilizar a
operação OR
– O MIPS oferece instruções lógicas para trabalhar com
constantes (modo de endereçamento imediato)
• AND imediato (andi)
• OR imediato (ori)
or $t0, $t1, $t2 # $t0 = $t1 | $t2
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões
Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Instruç
Instruções para tomada de decisões
• O que diferencia o computador de uma
calculadora simples é a capacidade de tomar
decisões
– Em linguagens de alto nível: if, else, goto
• Instruções de desvio condicional no MIPS
– Branch if equal (desvie se igual)
beq registrador1, registrador2, L1
– Essa instrução significa ir até a instrução rotulada por
L1 se o valor no registrador1 for igual ao valor no
registrador2
– O rótulo é alterado pelo compilador por endereços de
memória
Instruç
Instruções para tomada de decisões
Instruç
Instruções para tomada de decisões
• Instruções de desvio condicional no MIPS
– Branch if not equal (desvie se não for igual)
Bne registrador1, registrador2, L1
– Significa desviar o fluxo de execução para o rótulo L1
caso os valores contidos nos registradores registrador1 e
registrador2 forem diferentes
• Compilando if-then-else em desvios condicionais
– No segmento de código a seguir f, g, h, i e j são
variáveis. Se as cinco variáveis correspondem aos cinco
registradores de $s0 a $s4, qual é o código compilado
para esta instrução if em C?
if (i == j) f = g + h;
else f = g – h;
Instruç
Instruções para tomada de decisões
• Interface hardware/software
– Compiladores criam estruturas mais próximas a
linguagem humana como while, do until, etc.
– Compilando um loop while em C
bne $s3, $s4, Else
add $s0, $s1, $s2
j Exit
Else: sub $s0, $s1, $s2
Exit:
A instrução j implementa o desvio incondicional
(jump)
Instruç
Instruções para tomada de decisões
While (save[i] == k)
i+= 1;
Suponha que i e k correspondam aos registradores $s3 e
$s5 e base do vetor save esteja em $s6. Qual o código em
MIPS que corresponde a esse segmento C?
While (save[i] == k)
i+= 1;
– Suponha que i e k correspondam aos registradores $s3 e
$s5 e base do vetor save esteja em $s6. Qual o código
em MIPS que corresponde a esse segmento C?
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 += 1
j Loop
Exit:
Instruç
Instruções para tomada de decisões
Instruç
Instruções para tomada de decisões
• Bloco básico
• Testes de igualdade em assembly MIPS
– Uma seqüência de instruções sem desvios (exceto, possivelmente
no final) e sem destinos de desvio ou rótulos de desvio (exceto,
possivelmente, no início
– Uma das primeiras fases da compilação é desmembrar o programa
em blocos básicos
• Testes de igualdade em assembly MIPS
– Comparações são realizadas de forma que a instrução compara
dois registradores e atribui 1 a um terceiro registrador se o
primeiro for menor que o segundo; caso contrário, é atribuído 0
– Set on less than (atribuir se menor que)
slt $t0, $s3, $s4
– Significa que é atribuído 1 ao registrador $t0 se o valor no
registrador $s3 for menor que o valor no registrador $s4
– Operadores constantes são populares nas comparações
– Como o registrador $zero sempre tem 0, pode-se
comparar com zero; para comparar com outros valores,
existe uma versão com endereçamento imediato da
instrução slt:
slti $t0, $s2, 10 # $t0 =1 se $s2 < 10
• Interface hardware/software
– Os compiladores MIPS utilizam as instruções slt, slti,
beq, bne e o valor fixo 0 para criar todas as condições
relativas: igual, diferente, menor que, menor ou
igual,maior que, maior ou igual
– Assim, as construções lógicas de linguagens de alto
nível, como C e Java, são mapeadas em instruções
assembly de desvio condicional
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador
Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Arrays versus ponteiros
Vida real: instruções do IA-32
Falácias e armadilhas
Leituras e exercícios
Suporte para procedimentos
• Procedimentos ou funções
–
–
construções das linguagens de programação que
servem para estruturar programas, tornando-os mais
fáceis de entender, depurar e reutilizar
Seis etapas
1. Colocar parâmetros em um lugar onde o procedimento possa
acessá-lo
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
o chamou possa acessá-lo
6. Retornar o controle para o ponto de origem , pois um
procedimento pode ser chamado de vários pontos de um
programa
Suporte para procedimentos
Suporte a procedimentos no hardware
• O software do MIPS utiliza a seguinte convenção
na alocação de seus 32 registradores para
chamada de procedimentos:
• Instrução jump-and-link (jal)
– $a0 - $a3: quatro registradores de argumento, para
passar parâmetros;
– $v0 - $v1: dois registradores de valor, para valores de
retorno
– $ra: um registrador de endereço de retorno, para
retornar ao ponto de origem do programa que efetuou a
chamada
– Além de alocar esses registradores, o assembly do MIPS
inclui uma instrução apenas para os procedimentos: ela
desvia para um endereço e simultaneamente salva o
endereço da instrução seguinte no registrador $ra
(instrução jump-and-link)
– Jal EnderecoProcedimento
– O “link” é armazenado no registrador $ra, denominado endereço
de retorno
– Implícita na idéia de programa armazenado é a necessidade de ter
um registrador para manter o endereço da instrução atual que está
sendo executada, chamado de contador de programa ou PC
(program counter)
– A instrução jal salva PC+4 no registrador $ra para o link com a
instrução seguinte, a fim de preparar o retorno do procedimento
– Para apoiar tais situações, computadores como o MIPS utilizam
uma instrução de jump register (jr), significando um desvio
incondicional para o endereço especificado no registrador:
Jr $ra
– Assim, o programa que chama o procedimento, coloca os valores
de parâmetro em $a0 - $a3 e utiliza jal X par desviar para o
procedimento X.
– O procedimento X realiza as suas operações, coloca os resultados
em $v0 - $v1 e retorna o controle para o caller usando jr $ra
Suporte a procedimentos no hardware
Suporte a procedimentos no hardware
• Usando mais registradores
• Compilando um procedimento em C
– Suponha que um compilador precise de mais
registradores para um procedimento do que os quatro
disponíveis: utiliza-se a pilha (stack)
• Pilha
– Estrutura de dados – fila em que o último que entra é o
primeiro que sai
– Stack pointer é ajustado em uma word para cada
registrador salvo ou restaurado
• Push insere itens
• Pop remove itens
– O MIPS tem o registrador $sp, stack pointer, usado para
salvar os registradores necessários pelo procedimento
chamado
– As pilhas crescem de endereços maiores para menores
int exemplo_folha (int g, int h, int i, int j){
int f;
f = ( g + h ) – ( i + j );
Return f;
}
– As variáveis de parâmetro g, h, i e j correspondem ao registradores
de argumento $a0 - $a3 e f corresponde a $s0
exemplo_folha:
addi $sp, $sp,
itens)
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)
-12 # ajusta a pilha (3
# salva registrador
# salva registrador
# salva registrador
Suporte a procedimentos no hardware
Suporte a procedimentos no hardware
• Preparando o retorno
exemplo_folha:
addi $sp, $sp, -12 # ajusta a pilha (3 itens)
sw $t1, 8($sp) # salva registrador
sw $t0, 4($sp) # salva registrador
sw $s0, 0($sp) # salva registrador
add $t0, $a0, $a1 # $t0 contém g+h
add $t1, $a2, $a3 # $t1 contém i+j
sub $s0, $t0, $t1 # f = (g+h) – (i+j)
add $v0, $s0, $zero # copia f para reg. de retorno
exemplo_folha:
addi $sp, $sp, -12 # ajusta a pilha (3 itens)
sw $t1, 8($sp) # salva registrador
sw $t0, 4($sp) # salva registrador
sw $s0, 0($sp) # salva registrador
add $t0, $a0, $a1 # $t0 contém g+h
add $t1, $a2, $a3 # $t1 contém i+j
sub $s0, $t0, $t1 # f = (g+h) – (i+j)
add $v0, $s0, $zero # copia f para reg. de retorno
lw $s0, 0($sp)
lw $t0, 4($sp)
lw St1, 8($sp)
addi $sp, $sp, 12 # exclui 3 itens da pilha
jr $ra
Suporte a procedimentos no hardware
Suporte a procedimentos no hardware
• O software do MIPS separa 18 dos registradores
em dois grupos (convenção)
int fact (int n){
if (n < 1) return(1);
else return (n * fact(n-1));
}
fact:
addi $sp, $sp, -8
# ajusta pilha para 2 itens
sw $ra, 4($sp)
# salva endereço de retorno
sw $a0, 0($sp)
# salva o argumento n
slti $t0, $a0, 1
# teste para n < 1
beq $t0, $zero, L1 # se n>= 1, desvia para L1
addi $v0, $zero, 1 # prepara o “retorna 1”
addi $sp, $sp, 8
# retira dois itens da pilha
jr $ra
# retorna
L1:
addi $a0,$a0, -1
# argumento recebe n-1
jal fact
# chama fact com n-1
lw $a0, 0($sp)
# retorna de jal: restaura o arg. N
lw $ra, 4($sp)
# restaura o endereço de retorno
addi $sp, $sp, 8
# ajusta pilha para remover 2 itens
mul $v0, $a0, $v0
# calcula n * fact(n-1)
jr $ra
# retorna para o procedimento que chamou
– $t0-$t9: 10 registradores temporários que não são
preservados pelo procedimento chamado
– $s0-$s7: 8 registradores que precisam ser preservados
em uma chamada (se forem usados, o procedimento
chamado os salva e restaura)
• Procedimentos aninhados
– A solução é empilhar os valores dos registradores que
vão ser utilizados
• Código que chama: empilha $a?, $t?
• Procedimento chamado: empilha $ra e registradores usados por
ele
• Resumo: sempre é interessante empilhar registradores usados
pelo procedimento
Suporte a procedimentos no hardware
Suporte a procedimentos no hardware
• Interface hardware/software
• Reservando espaço para novos dados na pilha
– Uma variável em C é um local na memória, e sua interpretação
depende tanto do seu tipo quanto da classe de armazenamento
– A linguagem C possui duas classes de armazenamento: estáticas e
automáticas
– As variáveis automáticas são locais a um procedimento e são
descartadas quando o procedimento termina.
– As variáveis estáticas permanecem durante entradas e saídas de
procedimento
– As variáveis C declaradas fora de procedimentos são consideradas
estáticas, assim como as variáveis declaradas dentro de
procedimento com a palavra reservada static
– Para simplificar o acesso aos dados estáticos, o software do MIPS
reserva outro registrador, chamado de ponteiro global, e
referenciado como $gp
– $gp é um ponteiro global que referencia a memória para facilitar o
acesso através de operações simples de load e store.
– A pilha também é utilizada para armazenar variáveis
que são locais ao procedimento, que não cabem nos
registradores, como arrays ou estruturas locais
– O segmento da pilha que contém todos os registradores
salvos e as variáveis locais de um procedimento é
chamado de frame de procedimento ou registro de ativação
Suporte a procedimentos no hardware
Suporte a procedimentos no hardware
• Reservando espaço para novos dados no heap
• Reservando espaço para novos dados no heap
– Além de variáveis que são locais ao procedimentos,
programadores precisam de espaço para variáveis
estáticas e para estrutura de dados dinâmicas
O segmento de um
arquivo-objeto Unix que
contém o código em
linguagem de máquina
para as rotinas do
arquivo-fonte
– A forma de reservar memória permite que a pilha e o
heap cresçam um em direção ao outro, permitindo o uso
eficiente da memória enquanto os dois segmentos
aumentam e diminuem
– A forma pela qual os endereços são usados são
convenções do software e não fazem parte da
arquitetura MIPS
– A linguagem C aloca e libera espaço no heap com
funções explícitas
• malloc(): aloca espaço no heap
• free(): libera espaço no heap
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
ComunicandoComunicando-se com as pessoas
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas
Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
ComunicandoComunicando-se com as pessoas
• Compilando um procedimento de cópia de string
para demonstrar o uso de strings em C
void strcpy(char x[], char y[]){
int i;
i = 0;
while ( (x[i] = y[i]) != ‘\0’)
i += 1;
}
– Considerando que os endereços base para os arrays x e
y são encontrados em $a0 e $a1
strcpy:
addi $sp, $sp, -4
sw $s0, 0($sp)
add $s0, $zero, $zero
L1:
• Representação de caracteres
– Código ASCII de 8 bits
– Computadores necessitam de instruções que realizem a
movimentação de grupos de bits de palavras
lb $t0, 0($sp)
Sb $t0, 0($sp)
– Caracteres são representados por conjuntos de strings,
com geralmente três opções para representação:
• A primeira posição da string é reservada para indicar o tamnho
de uma string;
• Uma variável acompanhante possui o tamanho da string (como
uma estrutura);
• A última posição da string é ocupada por um caractere que
serve para marcar o final da string ( ‘\0’ na linguagem C; ‘$’
x86)
ComunicandoComunicando-se com as pessoas
strcpy:
addi $sp, $sp, -4
sw $s0, 0($sp)
add $s0, $zero, $zero
L1:
add $t1, $s0, $a1 # endereço de y[i] em $t1
lb $t2, 0($t1)
# $t2 = y[i], como é um byte,
não i * 4
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
L2:
lw $s0, 0 ($sp)
addi $sp, $sp, 4
jr $ra
ComunicandoComunicando-se com as pessoas
Conteú
Conteúdo
• Caracteres e strings em Java
•
•
•
•
•
•
•
•
•
– Unicode é uma codificação universal dos alfabetos da
maior parte das linguagens humanas
– 16 bits para representar um caractere
lh $t0, 0($sp)
sh $t0, 0($sp)
– Ao contrário da linguagem C, Java reserva uma word
para indicar o tamanho da string
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas Endereçamento no MIPS para operados imediatos e endereços de 32
bits
Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Endereç
Endereçamento no MIPS para imediatos
Endereç
Endereçamento no MIPS para imediatos
• Endereçamento no MIPS para operandos
imediatos e endereços de 32 bits
• Carregando uma constante de 32 bits
– Embora manter todas as instruções com 32 bits de
tamanho seja interessante, em certas situações é
conveniente ter uma constante de 32 bits ou endereços
de 32 bits
– Embora as constantes na maioria das vezes sejam curtas
e caibam em um campo de 16 bits, às vezes elas são
maiores
– O conjunto de instruções MIPS inclui a instrução load
upper immediate (lui) especificamente para atribuir os 16
bits mais altos de uma constante a um registrador,
permitindo que uma instrução subseqüente atribua os
16 bits mais baixos de uma constante
– Exemplo lui $t0, 255
– Qual é o código em assembly do MIPS para carregar
esta constante de 32 bits no registrador $s0?
– 0000 0000 0011 1101 0000 1001 0000 0000
lui $s0, 61
ori $s0, $s0, 2304
• Endereçamento em desvios condicionais e jumps
– As instruções de jump no MIPS possuem o
endereçamento mais simples possível. Elas utilizam o
último formato de instruções do MIPS, chamado de J,
que consiste em 6 bits para o campo de operação e o
restante dos bits para o campo de endereço
Endereç
Endereçamento MIPS para imediatos
Endereç
Endereçamento do MIPS para desvios
• Desvios condicionais e jumps
• Desvios condicionais
– 26 bits são alocados para o campo de endereço (32 – 6)
– Em desvios condicionais, é necessário especificar dois
operandos além do endereço de desvio: 6 bits de
opcode, 5 bits para registrador, 5 bits para registrador,
16 bits para endereço
– Se os endereços do programa tivessem que caber nesse
campo de 16 bits, nenhum programa poderia ser maior
que 2**16
– Uma alternativa seria especificar um registrador que
sempre seria somado ao endereço de desvio, de mode
que uma instrução de desvio pudesse calcular o
seguinte:
• Contador de programa = Registrador + endereço de desvio
– Qual registrador usar?
– A resposta vem da observação de como os desvios
condicionais são usados
– Os desvios condicionais são encontrados em loops e em
instruções if, de modo que costumam desviar para uma
instrução próxima.
– Por exemplo, cerca de metade de todos os desvios
condicionais nos benchmarks SPEC2000 vão para locais a
menos de 16 instruções
– Como o contador de instruções contém o endereço da
instrução atual, podemos desviar em +/- 2**15 palavras
da instrução atual se o usarmos o PC como registrador
a ser somado ao endereço.
Endereç
Endereçamento no MIPS para desvios
Endereç
Endereçamento de desvios no MIPS
• Desvios condicionais
• Exemplo
– Essa forma de endereçamento é denominada
endereçamento relativo ao PC
– Como na maioria dos computadores atuais, o MIPS
utiliza o endereçamento relativo ao PC para todos os
desvios condicionais.
– Instruções JAL chamam procedimentos que não tem
motivos para estarem próximas à instrução atual: a
arquitetura MIPS utiliza o formato longo (J) para
instruções de chamada de procedimento
– Como todas as instruções tem tamanho de 4 bytes, o
MIPS aumenta o alcance do endereçamento
interpretando o campo de endereçamento relativo a
word, e não ao byte: assim, o campo de 16 bits pode se
desviar para uma distância quatro vezes maior; da
mesma forma, o campo de 28 bits nas instruções de
jump também endereçam words.
Endereç
Endereçamento de desvios no MIPS
– Se considerarmos que o loop inicia na posição de
memória 80000, qual é o código de máquina para esse
loop?
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 += 1
j Loop
Exit:
Endereç
Endereçamento no MIPS
80000
0
0
19
9
4
0
80004
0
9
22
9
0
32
80008
35
9
8
0
80012
5
8
21
2
80016
8
19
19
1
80020
2
• Resumo dos modos de endereçamento
– Endereçamento de registrador: onde o operando é um
registrador;
– Endereçamento de base e deslocamento: onde o
operando está no local de memória cujo endereço é a
soma de um registrador e uma constante de instrução
– Endereçamento imediato: onde o operando é uma
constante dentro da própria instrução
– Endereçamento relativo ao PC: onde o endereçamento é
a soma do PC e uma constante na instrução
– 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
2000
Endereç
Endereçamento no MIPS
Conteú
Conteúdo
• Interface
hardware/software
•
•
•
•
•
•
•
•
•
– Embora as instruções
estudadas tem 32 bits em
tamanho, a arquitetura
MIPS tem extensões de 64
bits, em resposta a
necessidade de software
para programas maiores
• Uma única instrução pode
trabalhar com modos de
endereçamento diferentes:
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas Endereçamento no MIPS para operados imediatos e endereços de 32
bits Traduzindo e iniciando um programa
Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Traduzindo e iniciando um programa
Traduzindo e iniciando um programa
• Hierarquia de tradução
para a linguagem C
• Compilador
– Um programa em alto
nível é inicialmente
compilado para um
programa em assembly, e
depois montado em um
módulo objeto em
linguagem de máquina.
O link-editor combina os
vários módulos com as
rotinas de biblioteca
para resolver todas as
referências. O loader,
então, coloca o código
de máquina nos locais
apropriados em
memória, para ser
executado pelo
processador.
– O compilador transforma o programa C em um programa em
assembly, uma forma simbólica daquilo que a máquina entende.
• Montador
– As arquiteturas aceitam a programação em pseudo-instruções e
mnemônicos, que são convertidos em linguagem de máquina pelo
montador
– O montador transforma o programa assembly em um arquivo
objeto, que é uma combinação de instruções em linguagem de
máquina, dados e informações necessárias para colocar instruções
na memória
– Para produzir a versão binária das instruções, precisa determinar
os endereços de todos os rótulos - os montadores registram os
rótulos utilizados nos desvios e nas instruções de transferência de
dados por meio de uma tabela de símbolos, que contém pares de
símbolo e endereço
Traduzindo e iniciando um programa
Traduzindo e iniciando um programa
• Arquivo objeto em sistemas UNIX
• Linkeditor (link-edição)
– Cabeçalho: descreve o tamanho e posições das outras
partes do código
– Segmento de texto: código em linguagem de máquina
– Segmento de dados: contém os dados alocados por toda
a vida do programa (dados estáticos)
– Informações de relocação: identificam instruções e
words que dependem de endereços absolutos quando o
programa é carregado na memória
– Tabela de símbolos: contém os rótulos restantes que não
estão definidos, como referências externas
– Informações de depuração
Conteú
Conteúdo
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas Endereçamento no MIPS para operados imediatos e endereços de 32
bits Traduzindo e iniciando um programa Como os compiladores otimizam
Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
– Colocar os módulos de código e dados simbolicamente na
memória
– Determinar os endereços de rótulos de dados e instruções
– Remendar referências internas e externas
– O linkeditor produz um arquivo executável, que tem o mesmo
formato do arquivo objeto, exceto que não tem referências não
resolvidas
– Linkedição estática x dinâmica
– Desvantagens da linkedição estática:
• Rotinas de biblioteca fazem parte do código e não podem ser
atualizadas
• Carrega a biblioteca inteira, mesmo se parte da biblioteca nunca seja
chamada
– Desvantagens da linkedição dinâmica:
• Execução dos programas pode se tornar mais lenta
• Erros de execução em programas que necessitam de bibliotecas
dinâmicas não existentes.
Como os compiladores otimizam
• Compiladores
– Construídos considerando um conjunto de fases de
otimização
– Otimização: espaço de armazenamento e velocidade de
execução
Como os compiladores otimizam
Como os compiladores otimizam
• Compilador
• Otimizações locais
– Eliminação de sub-expressões comuns
– Afeta significantemente o desempenho dos programas
– Transformação de alto nível: procedimentos inline
– Loop unrolling – desdobramento de loops
• x[i] = x[i] + 4
• O cálculo do endereço de x[] ocorre duas vezes
– Outras otimizações
• for (i = 0; i < 100; i++) g ();
• Depois do loop unrolling.
• for (i = 0; i < 100; i += 2) { g (); g (); }
• Redução de força: substitui operações complexas por outras mais
simples, por exemplo um mult por um deslocamento à esquerda
• Propagação de constante: encontram constantes no código e as
propagam, encolhendo os valores de constante sempre que possível
– Otimizações
• Propagação de cópia: propaga valores que são cópias simples,
eliminando a necessidade de ler valores
• Otimizações locais atuam dentro de um bloco básico
• Otimizações globais atuam entre blocos básicos
• Alocação de registradores
• Eliminação de local de armazenamento: encontra locais com
armazenamento não utilizados
• Eliminação de código morto: encontra fragmentos de código que nunca
são utilizados – código morto ocorre com bastante freqüência.
Como os compiladores otimizam
Conteú
Conteúdo
• Otimizações globais
•
•
•
•
•
•
•
•
•
– Movimentação de
código
• Encontra código
que é invariante
no loop; um
trecho que
código que
calcula o mesmo
valor,
independente da
iteração corrente
do loop;
– Eliminação de
variável de
indução
• É um
combinação de
transformações
que reduz o
trabalho na
indexação de
arrays
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas Endereçamento no MIPS para operados imediatos e endereços de 32
bits Traduzindo e iniciando um programa Como os compiladores otimizam Um exemplo de ordenação na linguagem C para juntar tudo isso
Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Exemplo de ordenaç
ordenação na linguagem C
Exemplo de ordenaç
ordenação na linguagem C
• O procedimento swap
• O procedimento swap completo
void swap(int v[], int k){
int temp;
temp = v[k];
v[k] = v[k+1];
v[k+1] = temp;
}
sll $t1, $a1, 2 # registrador $t1 = k * 4
add $t1, $a0, $t1 # $t1 = v + (k*4)
lw $t0, 0($t1) # $t0 = v[k] (temp)
lw $t2, 4($t1) # $t2 = v[k+1];
sw $t2, 0($t0) # v[k] = registrador $t2
sw $t0, 4($t1) # v[k+1] = registrador $t0 (temp)
swap:
sll $t1, $a1, 2 # registrador $t1 = k * 4
add $t1, $a0, $t1 # $t1 = v + (k*4)
lw $t0, 0($t1) # $t0 = v[k] (temp)
lw $t2, 4($t1) # $t2 = v[k+1];
sw $t2, 0($t0) # v[k] = registrador $t2
sw $t0, 4($t1) # v[k+1] = registrador $t0 (temp)
jr $ra
Exemplo de ordenaç
ordenação na linguagem C
Exemplo de ordenaç
ordenação na linguagem C
• O procedimento sort
• Código para o procedimento sort (primeiro loop)
void sort(int v[], int n){
int i, j;
for(i=0; i < n; i++){
for(j=i-1; j >=0 && v[j] > v[j+1]; j --){
swap(v,j);
}
}
• Alocação de registradores para sort
– Os dois parâmetros do procedimento sort, v e n, estão
nos registradores de parâmetro $a0 e $a1, e alocamos o
registrador $s0 a i e o registrador $1 a j
– loops são compostos de 3 partes:
• Inicialização das variáveis de controle
• Teste da condição de controle
• Incremento da variável de controle
move $s0, $zero
#i=0
For1tst:
slt $t0, $s0, $a1
beq $t0, $zero, exit1
...
addi $s0, S0,1
j for1slt
exit1
Exemplo de ordenaç
ordenação da linguagem C
Exemplo de ordenaç
ordenação em C
• Código para o procedimento sort (segundo loop)
• Chamada de procedimento em sort
– for(j=i-1; j >=0 && v[j] > v[j+1]; j --)
– Teste de loop composto de duas partes:
• J >-0
• V[j] > v[j+1]
– swap(i,j)
– jal swap
• Passando parâmetros em sort
– Os procedimentos sort e swap utilizam como parâmetros os
registradores $a0, $a1
– É necessário então salvar os registradores em $s2 e $3 antes da
chamada do procedimento (melhor que salvar na pilha)
addi $s1, $1, -1 #j=i-1
For2tst:
slti $t0, $1, 0 # $t0 = 1 se j < 0
bne $t0, $zero, exit2
sll $t1, $s1, 2
# $t1 = j * 4
add $t2, $a0, $t1 # $t2 = v + (j+4)
lw $t3, 0($t2)
# $t3 = v[j]
lw $t4, 4($t2)
# $t4 = v[j+1]
slt $t0, $t4, $t3
# $t0 $t4 >= $t3
beq $t0, $zero, exit2
... (corpo do for 2)
add $1, $1, -1 # j -= 1
j for2tst
exit2:
• move $s2, $a0
• move $s3, $a1
– Depois passamos os parâmetros para swap da
seguinte forma:
• move $a0, $s2
• move $a1, $s1
Exemplo de ordenaç
ordenação em C
Conteú
Conteúdo
• Preservando registradores em sort
•
•
•
•
•
•
•
•
•
– Deve-se salvar o endereço de retorno $ra (lembre-se que
são loops aninhados)
– O procedimento sort também utiliza registradores
salvos, de modo que precisam ser salvos
addi $sp, $sp, -20 # 5 registradores
sw $ra, 16($sp)
# salva $ra na pilha
sw $s3, 12($sp)
# sala $s3 na pilha
sw $s2, 8($sp)
sw $s1, 4($sp)
sw $s0, 0($sp)
– Ao final do procedimento, os registradores devem ser
restaurados na ordem inversa
•
•
•
•
•
•
•
Introdução Operações no hardware do computador Operandos do hardware do computador Representando instruções no computador Operações lógicas Instruções para tomada de decisões Suporte para procedimentos no hardware do computador Comunicando-se com as pessoas Endereçamento no MIPS para operados imediatos e endereços de 32
bits Traduzindo e iniciando um programa Como os compiladores otimizam Um exemplo de ordenação na linguagem C para juntar tudo isso Vida real: instruções do IA-32
Falácias e armadilhas
Comentários finais
Leituras e exercícios
Vida real: instruç
instruções do IAIA-32
Vida real: instruç
instruções do IAIA-32
• Os projetistas
• IA-32
– Oferecem às vezes um conjunto de operações mais
poderosas do que aquelas encontradas no MIPS
• O objetivo é reduzir o número de instruções executadas por um
programa
• O perigo é que essa redução pode ocorrer ao custo da
simplicidade, aumentando o tempo que um programa leva
para executar, pois as instruções são mais lentas.
• Essa lentidão pode ser o resultado de um ciclo de clock mais
lento ou a requisição de mais ciclos de clock do que uma
seqüência mais simples
– Arquitetura que evoluiu ao longo do tempo, sendo produto de diferentes
grupos independentes, que modificaram a arquitetura por 20 anos,
acrescentando novos recursos ao conjunto de instruções original, como
alguém poderia acrescentar roupas em uma mala pronta
– Marcos importantes:
• 1978: Intel 8086 – extensão do assembly para o 8080; arquitetura de 16 bits com
registradores de 16 bits, com usos dedicados, ao contrário do MIPS, que tem
registradores de propósito geral; endereçamento de memória com 20 bits
• 1980: coprocessador 8087 anunciado; estende o conjunto original de instruções
em 60 instruções de ponto flutuante
• 1982: 80286 com endereçamento de memória de 24 bits com um modelo de
proteção de memória
• 1985: 80386, processador de 32 bits com novos modos de endereçamento e
registradores de 32 bits
• 1989-95: 80486, Pentium, ...
• 1997: instruções MMX nos processadores Pentium
• 1999: melhorias nas instruções SIMD e oito registradores adicionais; instruções
SSE (Streaming SIMD extensions)
• 2001: extensões com 144 instruções adicionais para lidar com operações
multimídia, exploração da computação paralela nos chips
• 2003: AMD anuncia extensões arquitetônicas para aumentar o espaço de
endereçamento de memória de 32 para 64 bits, alargando os registradores para
64 bits
Vida real: instruç
instruções do IAIA-32
Falá
Falácias e armadilhas
• Registradores e instruções
• Falácias
– Instruções mais poderosas significam
maior desempenho
– Escreva em assembly para ter melhor
desempenho
• Armadilha
– Esquecer que os endereços seqüenciais de
word em máquinas com endereçamento
em bytes não diferem em 1.
Comentá
Comentários finais
Comentá
Comentários finais
• Programa armazenado
• Instruções MIPS
– Permite a construção de máquinas de propósito geral
– A seleção de um conjunto de instruções que a máquina possa
entender exige um equilíbrio delicado entre a quantidade de
instruções necessárias para executar programas, a quantidade de
ciclos de clock por instrução e a velocidade do
– Princípios de projeto:
• Simplicidade favorece a regularidade: instruções de mesmo tamanho e
se possível com o mesmo significado quanto aos operandos
• Menor é mais rápido: o desejo de velocidade é o motivo para que o
MIPS tenha apenas 32 registradores
• Torne os casos comuns mais velozes: alguns exemplos são os desvios
em relação ao contador de programa e endereçamento imediato para
constantes
• Um bom projeto exige bons compromissos: exemplo é o compromisso
de manter todas as instruções com o mesmo tamanho frente à
necessidade de representação de constantes que necessitam de mais
bits para a representação
– Cada categoria de instruções MIPS está associada a
construções que aparecem nas linguagens de
programação
• Instruções aritméticas correspondem às operações encontradas
nas instruções de atribuição
• Instruções de transferência de dados provavelmente ocorrerão
quando se lida com estruturas de dados, como arrays e
estruturas
• Os desvios condicionais são usados em instruções if e em loops
• Os jumps incondicionais são usados em chamadas de
procedimento e retornos, e para instruções case/switch
Leituras e exercí
exercícios
• Leituras
– Patterson, capítulo 2
• Exercícios
– Patterson, capítulo 2