Parte 1:

Organização de Computadores

7. Compilando programas

Texto base: capítulo 3

Computer Organization and Design: The Hardware/Software
Interface
J.L. Hennessy e D.A. Patterson

IC - UFF
 MIPS: Visão do programador
 Alguns registradores (32 bits)
 $s0 - $s7: uso geral, preservados
 $t0 - $t9: temporários, não preservados
 $sp: apontador de pilha, preservado
 $ra: endereço de retorno, preservado
 $a0 - $a3: argumentos, não preservados
 $v0 - $v1: valores de retorno, não preservados
IC - UFF
 Algumas instruções

Categoria Instrução Exemplo Significado

Aritmética add add $s1,$s2,$s3 $s1 = $s2 + $s3
subtract sub $s1,$s2,$s3 $s1 = $s2 - $s3
Transf. de dados load word lw $s1,100($s2) $s1=memo[$s2+100]
store word sw $s1,100($s2) memo[$s2+100]=$s1

IC - UFF
 Formato das instruções
Campo Significado
op código da operação
rs registro fonte do primeiro operando
rt registro fonte do segundo operando
rd registro destino do operando
shamt número de bits deslocados
funct função; indica a variante do código de operação

Formato tipo R
op rs rt rd shamt funct
6 bits 5 bits 5 bits 5 bits 5 bits 6 bits
Formato tipo I
op rs rt endereço
6 bits 5 bits 5 bits 16 bits
IC - UFF
 Um pequeno segmento em C
 Variáveis a  e colocadas nos
registradores $s1  $s5 pelo compilador

Código C Código MIPS

a = b + c;
d = a – e;

IC - UFF
 Um pequeno segmento em C
 Variáveis a  e colocadas nos
registradores $s1  $s5 pelo compilador

Código C Código MIPS

a = b + c; add $s1,$s2,$s3
d = a – e; sub $s4,$s1,$s5

IC - UFF
Um pouco mais de complexidade

 Variáveis f  j em $s0  $s4

Código C Código MIPS

f = (g + h) – (i + j);

IC - UFF
Um pouco mais de complexidade

 Variáveis f  j em $s0  $s4

Código C Código MIPS

f = (g + h) – (i + j); add $t0,$s1,$s2

add $t1,$s3,$s4
sub $s0,$t0,$t1

IC - UFF
 Um operando em memória
 A é um array de 100 posições; g e h
estão em $s1 e $s2; endereço de base de
A está em $s3
Código C Código MIPS

g = h + A[8];

IC - UFF
 Um operando em memória
 A é um array de 100 posições; g e h
estão em $s1 e $s2; endereço de base de
A está em $s3
Código C Código MIPS
?

g = h + A[8]; lw $t0,32($s3)
add $s1,$s2,$t0

IC - UFF
 Ainda outro array
 A é um array de 100 posições; h está em
$s2; endereço de base de A está em $s3

Código C Código MIPS

A[12] = h + A[8];

IC - UFF
 Ainda outro array
 A é um array de 100 posições; h está em
$s2; endereço de base de A está em $s3

Código C Código MIPS

A[12] = h + A[8]; lw $t0,32($s3)

add $t0,$s2,$t0
sw $t0,48($s3)
IC - UFF
 Array com índice variável
 A é um array de 100 posições; g, h e i
estão em $s1, $s2 e $s4; endereço de
base de A está em $s3
Código C Código MIPS

g = h + A[i];

IC - UFF
 Array com índice variável
 A é um array de 100 posições; g, h e i
estão em $s1, $s2 e $s4; endereço de
base de A está em $s3
Código C Código MIPS

g = h + A[i]; add $t1,$s4,$s4

add $t1,$t1,$t1
add $t1,$t1,$s3
lw $t0,0($t1)
IC - UFF add $s1,$s2,$t0
 Outras instruções

Categoria Instrução Exemplo Significado

Salto condicional beq beq $s1,$s2,L if($s1== $s2) go to L
bne bne $s1,$s2,L if($s1!= $s2) go to L
Salto incond. j j End go to End

IC - UFF
 Tomando decisões
 i e j estão em $s3 e $s4; f, g e h estão em
$s0, $s1 e $s2
Código C Código MIPS

if (i == j)
f = g + h;
else
f = g - h;
IC - UFF
 Tomando decisões
 i e j estão em $s3 e $s4; f, g e h estão em
$s0, $s1 e $s2
Código C Código MIPS

if (i == j) bne $s3,$s4,Else
f = g + h; add $s0,$s1,$s2
else j Exit
f = g - h; Else: sub $s0,$s1,$s2
Exit:
IC - UFF
 Loop e índice variável
 A é um array de 100 posições; g, h, i e j
estão em $s1, $s2, $s3 e $s4; endereço de
base de A está em $s5. Ex:

Loop: g = g + A[i];
i = i + j;
if (i != h) go to Loop;

IC - UFF
 Código do exemplo do Loop

Loop: add $t1, $s3, $s3

add $t1, $t1, $t1
add $t1, $t1, $s5
lw $t0, 0($t1)
add $s1, $s1, $t0
add $s3, $s3, $s4
bne $s3, $s2, Loop
IC - UFF
 Evitando o go to: while
 save é um array; i, j e k estão em $s3,
$s4 e $s5; base de save está em $s6. Ex:

while (save[i] == k)
i = i + j;

IC - UFF
 Código do exemplo com while
Loop: add $t1, $s3, $s3
add $t1, $t1, $t1
add $t1, $t1, $s6
lw $t0, 0($t1)
bne $t0, $s5, Exit
add $s3, $s3, $s4
j Loop
Exit:
IC - UFF
 Mais algumas instruções

Categoria Instrução Exemplo Significado

Salto condicional slt slt $s1,$s2,$s3 if($s2<$s3) $s1=1;
else $s1=0
Salto incond. jr j $t0 go to (Reg)

IC - UFF
 E o switch?
 Variáveis f a k estão de $s0 a $s5; $t2
contém 4; $zero = 0
switch (k) {
case 0: f = i + j; break;
case 1: f = g + h; break;
case 2: f = g - h; break;
case 3: f = i - j; break;
}
IC - UFF
 Código para o switch
slt $t3, $s5, $zero
bne $t3, $zero, Exit
slt $t3, $s5, $t2
beq $t3, $zero, Exit
add $t1, $s5, $s5
add $t1, $t1, $t1
add $t1, $t1, $t4
lw $t0, 0($t1) # ($t0)=JumpTable[k]
jr $t0
L0: add $s0, $s3, $s4
j Exit
L1: add $s0, $s1, $s2
j Exit
L2: sub $s0, $s1, $s2
j Exit
L3: sub $s0, $s3, $s4
Exit:

obs.: os endereços dos rótulos L0L3 encontram-se em

quatro palavras seqüenciais começando no endereço
IC - UFF
indicado em $t4
 Utilizando procedures
 Alocação de registros para passagem de
parametros e valores
 $a0 - $a3: passagem de argumentos
 $v0 - $v1: retorno de valores
 $ra: endereço de retorno
 nova instrução: jal ProcedureAddress (salva
endereço da próxima instrução em $ra)
 mais parametros/valores: uso da pilha
IC - UFF
 Procedures: um caso simples

int proc_simples (int g, int h, int i, int j)

{
int f;

f = (g + h) – (i + j);
return f;
}

IC - UFF
 Código MIPS: proc_simples
proc_simples:
sub $sp, $sp, 12
sw $t1, 8($sp)
sw $t0, 4($sp)
sw $s0, 0($sp)
add $t0, $a0, $a1
add $t1, $a2, $a3
sub $s0, $t0, $t1
add $v0, $s0, $zero
lw $s0, 0($sp)
lw $t0, 4($sp)
lw $t1, 8($sp)
add $sp, $sp, 12
jr $ra
IC - UFF
 Recursividade
 Cálculo de fatorial
int fat (int n)
{
if (n < 1)
return (1);
else
return (n * fat(n-1));
}
IC - UFF
 Código MIPS: fatorial
fat:
sub $sp, $sp, 8
sw $ra, 4($sp)
sw $a0, 0($sp) # salva n
slt $t0, $a0, 1
beq $t0, $zero, L1 # se n>=1, vá p/ L1
add $v0, $zero, 1
add $sp, $sp, 8
jr $ra
L1: sub $a0, $a0, 1 #n=n-1
jal fat # chama fat(n-1)
lw $a0, 0($sp)
lw $ra, 4($sp)
addi $sp, $sp, 8
mult $v0, $a0, $v0 # retorna n*fat(n-1)
IC - UFF
jr $ra
 Arrays x ponteiros
clear1 (int array[], int size)
{
int i;
for (i = 0; i < size; i++)
array[i] = 0;
}

clear2 (int *array, int size)

{
int *p;
for (p = &array[0]; p <&array[size]; p++)
*p = 0;
}
IC - UFF
 Código clear1 e clear2

move $t0, $zero move $t0, $a0

loop1: add $t1, $t0, $t0 loop2: sw $zero, 0($t0)
add $t1, $t1, $t1 addi $t0, $t0, 4
add $t2, $a0, $t1 add $t1, $a1, $a1
sw $zero, 0($t2) add $t1, $t1, $t1
addi $t0, $t0, 1 add $t2, $a0, $t1
slt $t3, $t0, $a1 slt $t3, $t0, $t2
bne $t3, $zero, loop1 bne $t3, $zero, loop2

IC - UFF
 Um pouco mais rápido ...

move $t0, $zero move $t0, $a0

loop1: add $t1, $t0, $t0 add $t1, $a1, $a1
add $t1, $t1, $t1 add $t1, $t1, $t1
add $t2, $a0, $t1 add $t2, $a0, $t1
sw $zero, 0($t2) loop2: sw $zero, 0($t0)
addi $t0, $t0, 1 addi $t0, $t0, 4
slt $t3, $t0, $a1 slt $t3, $t0, $t2
bne $t3, $zero, loop1 bne $t3, $zero, loop2

IC - UFF
 Pseudo-instruções
 A linguagem de montagem pode ter
instruções que não sejam implementadas
em hardware: pseudo-instruções
 Exemplo:
 move $t0, $t1 # $t0  $t1 ( a MIPS!)
 add $t0, $zero, $t1 # equivalente ao move

IC - UFF
 Transformando *.c em *.exe
programa C

programa
fonte

IC - UFF
 Transformando *.c em *.exe
programa C

compilador

programa assembly

IC - UFF
 Transformando *.c em *.exe
programa C

compilador

programa assembly
linguagem de
máquina!
montador

módulo objeto
IC - UFF
 Transformando *.c em *.exe
programa C

compilador

programa assembly
linguagem de
máquina!
montador

módulo objeto routina de biblioteca

IC - UFF
 Transformando *.c em *.exe
programa C

compilador

podemos ter vários

programa assembly
módulos objeto e
várias rotinas de biblioteca

montador

módulo objeto routina de biblioteca

IC - UFF
 Transformando *.c em *.exe
programa C
linguagem de
máquina!
compilador

programa assembly módulo executável

montador ligador

módulo objeto routina de biblioteca

IC - UFF
 Transformando *.c em *.exe
programa C memória

compilador carregador

programa assembly módulo executável

montador ligador

módulo objeto routina de biblioteca

IC - UFF
 Olhando cada fase . . .
 Identificação dos arquivos:
 Unix: arq.c, arq.s, arq.o, a.out
 MS-DOS: arq.c, arq.asm, arq.obj, arq.exe
 Compilação
 código objeto pode ser produzido
diretamente
 fases
IC - UFF
 Montagem
 Transforma um programa em linguagem
de montagem em um programa objeto:
instruções de máquina, dados e
informações para colocação das
instruções em memória
 Tabela de símbolos: associação entre
rótulos e seus endereços
IC - UFF
 Arquivo objeto (e.g., Unix)
 Cabeçalho: tamanho e posição dos
componentes do arquivo objeto
 Segmento de texto: código de máquina
 Segmento de dados: dados estáticos e
dinâmicos
 Inf. de relocação: identifica instruções e
palavras de dados que dependem de endereços
absolutos quando programa é carregado
IC - UFF
 Arquivo objeto (cont.)
 Tabela de símbolos: símbolos que não foram
resolvidos (referências externas)
 Informação para depuração: possibilita
associação entre instruções em C e instruções
de máquina; facilita a leitura de estruturas de
dados

IC - UFF
 Um arquivo objeto
Cabeçalho
Nome Procedure A
Tamanho do texto 10016
Tamanho dos dados 2016
Segmento de texto Endereço Instrução
0 lw $a0, 0($gp)
4 jal 0
... ...
Segmento de dados 0 (X)
... ...
Inf. de relocação Endereço Tipo de instrução Dependência
0 lw X
4 jal B
Tabela de símbolos Rótulo Endereço
X -
B -

IC - UFF
 Ligação
 Compilação separada: necessidade do ligador
 Ligador pega um programa objeto e produz um
módulo carregável
 Ligação dinâmica em tempo de carregamento:
incorporação de novas versões; compartilhamento de
código
 Ligação dinâmica em tempo de execução: só aloca
memória p/ o que for usado; instalação de módulos
não existentes quando da programação da aplicação
IC - UFF
 Carregamento
 Definição de endereçamento:
 carregamento absoluto
 limitado: problema com modificações
 carregamento relocável
 problema: memória virtual (swapping)
 carregamento dinâmico em tempo de
execução

IC - UFF
 Um programa na memória
$sp 
Pilha



Dados dinâmicos

Dados estáticos

Texto
$pc 
PCB
IC - UFF
 Leitura suplementar
 Apêndice A, itens A1 até A6, Computer
Organization and Design: The
Hardware/Software Interface, J.L.
Hennessy e D.A. Patterson
 Apêndice 7A, Operating Systems:
Internals and Design Principles, W.
Stallings
IC - UFF