Linguagem de Máquina - Luciano José Senger

Introdução Introdu ão 

Organização Organiza ão e Arquitetura 

de computadores 

Instruções: a linguagem de máquina 

Prof. Dr. Luciano José Senger 

• Para controlar o hardware do computador, é 

necessário falar a sua linguagem 

• 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 

Conteúdo 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 

Introdução Introdu ão 

Introdução Introdu ão Introdução 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) 

• É 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 

– Burks, Goldstine e von Neumann, 1947 

• 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 

Control 

Datapath 

Exec 

Memory Devices 

Fetch 

Decode 

Input 

Output 

• 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


• Introdução 

• Operações no hardware do computador 








bits 








Operações Opera ões do hardware do computador 

• O número natural de operandos para uma 

operação de adição é três 

• 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: 

• Princípio de projeto 1: simplicidade favorece a 

regularidade 

Operações Opera ões no hardware do computador 

• 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? 


• 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 # soma b+c é colocada em a 

add a, a, d # soma b+c+d está em a 

add a, a, e # soma b+c+d+e está em a 


• Contra-exemplo: IA-32 (p.e. Pentium) 

– ADD AX,BX 

• Compilando duas instruções de atribuição C no 

MIPS: 

a = b + c; 

d = a – e; 

– a tradução é realizada pelo compilador 

– Em MIPS: 

add a, b, c 

sub d, a, e 



• Operações no hardware do computador 








bits 







• 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) 


• 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 

– 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 


• Operandos na memória 

– 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 


$at 

$gp 

$sp 

$fp 

$ra 

Name 

$zero 

$v0 - $v1 

$a0 - $a3 

$t0 - $t7 

$s0 - $s7 

$t8 - $t9 

Register 

Number 

0 

1 

2-3 

4-7 

8-15 

16-23 

24-25 

28 

29 

30 

31 

reserved for assembler 

arguments 

Usage 

constant 0 (hardware) 

returned values 

temporaries 

saved values 

temporaries 

global pointer 

stack pointer 

frame pointer 

return addr (hardware) 

Preserve 

on call? 


n.a. 

n.a. 

no 

yes 

no 

yes 

no 

yes 

yes 

yes 

yes 

• A convenção no MIPS é usar nomes com um sinal 

de $ seguido de dois caracteres para representar 

um registrador. 

– $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 


• A instrução que copia dados da memória para um 

registrador tradicionalmente é chamada de load 

• 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


• Compilando uma atribuição quando um operando 

está na memória 

– 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] 


• Interface hardware/software 

– 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 


• 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 de computador 

• Compilando uma atribuição quando um 

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 


• No MIPS, palavras precisam começar em 

endereços que sejam múltiplos de 4 (restrição de 

alinhamento) 

• 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 



– 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


• 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 




• Operandos do hardware do computador 







bits 








Representando instruções instru ões no computador 

• Traduzindo uma instrução assembly MIPS para 

uma instrução de máquina: 

add $t0, $s1, $s2 

0 

17 

18 

• 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 

8 

0 

32 


• 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 


• 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? 


• 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 

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


• Problemas de endereçamento 

– 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. 


• Traduzindo do assembly MIPS para a linguagem de máquina 

– Se $t1 possui a base do array A e $s2 corresponde a h: 

– A[300] = h + A[300]; 

– É compilada para: 

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. 

35 

0 

43 

9 

18 

9 

8 

8 

8 

1200 

1200 


• 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 

8 

0 

32 


• Formato I 

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 


– A instrução lw é representada por 35 no opcode 

– 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 

– 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 

35 

0 

43 

decimal, mas na verdade são representados em binário. 


9 

18 

9 

8 

8 

8 

8 

1200 

0 

1200 




• Representando instruções no computador 






bits 








32

Operações Opera ões lógicas l gicas 

• Embora o projeto do primeiros computadores se 

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 

Operações lógicas 

Shift a esquerda 

Shift a direita 

AND bit a bit 

OR bit a bit 

NOT bit a bit 

Operadores C 

> 

& 


• Operações de deslocamento 

| 

~ 

Operadores Java 

> 

& 

| 

~ 

Instruções MIPS 

sll 

srl 

and, andi 

or, ori 

nor 

– O deslocamento lógico à esquerda de i bits gera o mesmo 

resultado que multiplicar por 2^i 


– 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 


or $t0, $t1, $t2 # $t0 = $t1 | $t2 





• Operações lógicas 





bits 









• Operações de deslocamento (shifts) 

– 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

Instruções 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; 



– Compiladores criam estruturas mais próximas a 

linguagem humana como while, do until, etc. 

– Compilando um loop while em 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? 


• Bloco básico 

– 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 


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) 


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: 


• Testes de igualdade em assembly MIPS 

– 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 


– 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







• Instruções para tomada de decisões 




bits 




• Arrays versus ponteiros 




Suporte para procedimentos 

• O software do MIPS utiliza a seguinte convenção 

na alocação de seus 32 registradores para 

chamada de procedimentos: 

– $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) 

Suporte a procedimentos no hardware 

• Usando mais registradores 

– 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 

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 


• Instrução jump-and-link (jal) 

– 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 


• Compilando um procedimento em C 

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, -12 # ajusta a pilha (3 

itens) 

sw $t1, 8($sp) # salva registrador 


sw $s0, 0($sp) # salva registrador



addi $sp, $sp, -12 # ajusta a pilha (3 itens) 



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 


• O software do MIPS separa 18 dos registradores 

em dois grupos (convenção) 

– $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 



– 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. 


• Preparando o retorno 


addi $sp, $sp, -12 # ajusta a pilha (3 itens) 



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 


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 


• Reservando espaço para novos dados na pilha 

– 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


• 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 







• Suporte para procedimentos no hardware do computador 



bits 








Comunicando-se Comunicando 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: 


• Reservando espaço para novos dados no heap 

– 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 


• 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) 


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


• 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 

Endereçamento Endere amento no MIPS para imediatos 

• Endereçamento no MIPS para operandos 

imediatos e endereços 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 

Endereçamento Endere amento MIPS para imediatos 

• Desvios condicionais e jumps 

– 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 









• Comunicando-se com as pessoas 


bits 








Endereçamento Endere amento no MIPS para imediatos 

• Carregando uma constante de 32 bits 

– 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çamento Endere amento do MIPS para desvios 

• Desvios condicionais 

– 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çamento Endere amento no MIPS para desvios 

• Desvios condicionais 

– 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çamento Endere amento de desvios no MIPS 

80000 

80004 

80008 

80012 

80016 

80020 

0 

0 

35 

5 

8 

2 

9 

9 

8 

19 

19 

22 

8 

21 

19 

Endereçamento Endere amento no MIPS 

• 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: 

0 

9 

9 

2000 

4 

0 

0 

2 

1 

0 

32 

Endereçamento Endere amento de desvios no MIPS 

• Exemplo 

– 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çamento Endere amento no MIPS 

• 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 











bits 








Traduzindo e iniciando um programa 

• Hierarquia de tradução 

para a linguagem C 

– 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. 


• Arquivo objeto em sistemas UNIX 

– 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 











bits 

• Traduzindo e iniciando um programa 








• Compilador 

– 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 


• Linkeditor (link-edição) 

– 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


• Compilador 

– Afeta significantemente o desempenho dos programas 

– Transformação de alto nível: procedimentos inline 

– Loop unrolling – desdobramento de loops 

•for (i = 0; i < 100; i++) g (); 

• Depois do loop unrolling. 

•for (i = 0; i < 100; i += 2) { g (); g (); } 

– Otimizações 

• Otimizações locais atuam dentro de um bloco básico 

• Otimizações globais atuam entre blocos básicos 

• Alocação de registradores 


• 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 

Exemplo de ordenação ordena ão na linguagem C 

• O procedimento swap 

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) 


• Otimizações locais 

– Eliminação de sub-expressões comuns 

• x[i] = x[i] + 4 

• O cálculo do endereço de x[] ocorre duas vezes 

– Outras otimizações 

• 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 

• Propagação de cópia: propaga valores que são cópias simples, 

eliminando a necessidade de ler valores 

• 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. 











bits 


• Como os compiladores otimizam 







• O procedimento swap completo 

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


• O procedimento sort 

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 

Exemplo de ordenação ordena ão da linguagem C 

• Código para o procedimento sort (segundo loop) 

– 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] 

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: 

Exemplo de ordenação ordena ão em C 

• 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 


• Código para o procedimento sort (primeiro loop) 

– 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ção ordena ão em C 

• Chamada de procedimento em sort 

– 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) 

• move $s2, $a0 

• move $s3, $a1 

– Depois passamos os parâmetros para swap da 

seguinte forma: 

• move $a0, $s2 

• move $a1, $s1 











bits 


• Como os compiladores otimizam 

• Um exemplo de ordenação na linguagem C para juntar tudo isso 





Vida real: instruções instru ões do IA-32 IA 32 

• Os projetistas 

– 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 


• Registradores e instruções 

Comentários Coment rios finais 

• Programa armazenado 

– 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 


• IA-32 

– 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 

Falácias Fal cias e armadilhas 

• 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ários Coment rios finais 

• Instruções MIPS 

– 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ícios exerc cios 

• Leituras 

– Patterson, capítulo 2 

• Exercícios 

– Patterson, capítulo 2

Linguagem de Máquina - Luciano José Senger

Create successful ePaper yourself

Delete template?

Save as template?