LINGUAGEM DE MQUINA 3.1 Introduo Computador: Linguagem de mquina. Conjunto de instrues. Introduo passo-a-passo.

so. Linguagens de mquinas: Parecidas (dialetos) princpios semelhantes. Objetivos da linguagem: Facilitar construo do hardware e compiladores. Maximizar a performance. Minimizar o custo. Neste captulo: Linguagem C, Assembly, Linguagem de Mquina. Instrues: MIPS (NEC, Nintendo, Silicon Graphics, Sony). 3.2 Operaes do Hardware Todo computador: ops. Aritmticas.
1

 MIPS: add a,b,c

# ab+c

* nota: os nomes reais dos operadores no so a, b e c. Sero vistos em Breve. Instrues so mais rgidas que em lin. de alto nvel sempre 3 operandos. Exemplo: somar variveis b, c, d, e, colocando a soma em a: vrios passos: add a,b,c add a,a,d add a,a,e # a b+c # a b+c+d # a b+c+d+e

Smbolo # Comentrio (at o fim da linha). MIPS: sempre 3 operandos. Simplifica o hardware. 4 princpios de projeto. Princ. 1: Simplicidade favorece Regularidade.
2

Exemplo: C Assembly. a = b + c; d = a e; Em MIPS: add a,b,c sub d,a,e

Exemplo: instruo complexa: f = (g + h) + (i + j); Dividir o comando em vrias instr.: t0 e t1: variveis temporrias. add t0,g,h add t1,i,j sub f,t0,t1
3

3.3 Operandos Alto nvel: qualquer operando. Ling. de mquina: alguns operandos. Apenas alguns registradores. No MIPS: registradores de 32 bits. 32 bits: word (palavra). MIPS: 32 registradores. Operandos: sempre um dos 32 registradores internos (no memory). Razo para to poucos registradores: Princpio 2. Princpio 2: Menor mais rpido. > no. de regs > ciclo de clock. No MIPS - nos. : de 0 a 31. - nomes: iniciam em $.

Variveis: $s0, $s1, ... Reg. temporrios: $t0, $t1, ...

4

Exemplo: Compil. prog. em C. f = (g + h) (i + j); f, g, h, i $s0, $s1, $s2, $s3, $s4. Temporrias $t0, $t1. add $t0,$t1,$t2 add $t1,$t3,$t4 sub $s0,$t0,$t1 Muitas vezes: Variveis demais. Arrays, Structures. Quando os reg. internos no so suficientes memria (milhes de posies). MIPS Aritmtica ocorre apenas nos registradores. Instrues de transferncia: Memria Registradores (load). Registradores Memria (store).
5

 Memria:

Posies de memria: nmeros. 1 byte por posio. Memria Registradores (load). lw (load word) Sintaxe: lw RegAlvo, const(RegBas) Exemplo: A um array de 100 words. Variveis g e h $s1 e $s2. Endereo base do array: armazenado em $s3.
6

 Traduzir para assembly: g=h+A[8]; Soluo: lw $t0,8($s3) add $s1,$s2,$t0 a constante 8 chamada de offset. O registrador adicionado o registrador de base. UMA COMPLICAO A memria agrupada em bytes: Posio 0: 1 byte. Posio 1: 1 byte. etc. O registrador tem 4 bytes. Memria Registradores: Sempre em grupos de 4 bytes.
7

 Palavras sempre devem comear em endereos mltiplos de 4 (0, 4, 8, 12,...) Restrio de alinhamento (muitas arquiteturas transferncia rpida).

Little Endian x Big Endian (MIPS) O valor do ndice de um vetor dever ser sempre multiplicado por 4: lw $t0,8($s3) lw $t0,32($s3)

 Transferncia Memria Registradores (store). sw (store word) Sintaxe: sw RegFonte, const(RegBas) Exemplo: Compilar... A[12] = h + A[8]; lw $t0,32($s3) add $t0,$s2,$t0 sw $t0,48($s3) Exemplo: Usando um ndice de array. g = h + A[i]; A um array de 100 elementos. $s3 o registrador de base. g, h, i $s1, $s2, $s4. necessrio multiplicar o ndice por 4.
9

add $t1,$s4,$s4 add $t1,$t1,$t1 add $t1,$t1,$s3 lw $t0,0($t1) add $s1,$s2,$t0

# $t1=2*i # $t1=4*i # $t1=end. De A[i] # $t0=A[i] # g=h+A[i]

Interface Hardware/Software Muitas vezes: + vars. que regs. Mais freqentemente usados nos registradores. Restantes: memria. Processo de colocar variveis menos usadas na memria: spilling registers (vazamento de registradores). Registradores: + rpidos que memria. Dados so mais teis em registradores (permitem operaes log./arit.). Resumo das instrues vistas at agora:

10

3.4 Representao de Instrues no Computador Humanos: base 10. Comput.: base 2. 12310=11110112. Instrues: nmeros. MIPS: 32 bits Instrues compostas. Cada byte contm: opcode, operandos. Registradores no MIPS: $s0 a $s7 regs. 16 a 23. $t0 a $t7 regs. 8 a 15. Exemplos: $s0reg 16; $s1reg 17; $t0reg 8; $t1reg 9.
11

Instrues de linguagem de mquina no MIPS Exemplo: add $t0,$s1,$s2 MIPS: vrios campos (opcode, registradores, etc.). Formato de instruo de soma com registradores: 0 17 18 8 0 32

Cada segmento: um campo. Primeiro e ltimo campos: opcode. Primeiro campo: tipo de operao (soma). ltimo campo: modo da operao (soma com 2 registradores). Segundo campo: primeira fonte (17=$s1).
12

 Terceiro campo: Segunda fonte (18=$s2). Quarto campo: Registrador de destino (8=$t0). Na verdade: os campos so nmero binrios:
000000 10001 10010 01000 00000 100000

Palavra:
00000010001100100100000000100000 = 00000010 00110010 01000000 00100000 = 0232402016.

Nome: Linguagem de mquina. Instrues: cdigo de mquina. Layout da instruo: formato da instruo. MIPS: todas as instrues: 32 bits. Campos do MIPS: op
6 bits

rs
5 bits

rt
5 bits
13

rd
5 bits

shamt Funct
5 bits 6 bits

 op: opcode. rs: primeiro registrador fonte. rt: segundo registrador fonte. rd: registrador de destino. shamt: Shift ammout. Visto no cap. 4. No ser usado agora. funct: seleciona variante da instruo. Instrues de outro tipo Instrues load e store necessitam: 1 registrador de fonte ou destino. 1 registrador de base. 1 offset (16 bits): acesso a grandes arrays e estruturas de dados. Regra de projeto 3: bom projeto requer bom compromisso. No MIPS: todas as instrues so de 32 bits (simplicidade). H instrues de diversos tipos.
14

 Instruo de registradores: R-type (tipo r). Instruo de load e store: I-type (tipo I): op
6 bits

rs
5 bits

rt
5 bits

endereo
16 bits

Registrador de base: rs. Registrador de fonte ou origem: rt. Endereo de 16 bits: offset entre 215. O offset somado ao rgistrador de base. Exemplo: lw $t0,32 # $t0 A[8]

op
6 bits
35

rs
5 bits
19($s3)

rt
5 bits
8($t0)

endereo
16 bits
32

6 bits

5 bits

5 bits

16 bits

15

 Mltiplos formatos: complicam o hardware. Manter os formatos similares (3 1os campos iguais. Codificao das instrues vistas at agora:

Notar: add e sub: Mesmo opcode: 0. Diferente variao: 35 e 43. Exemplo: traduo de C para assembly e linguagem de mquina. A[300] = h + A[300]; $t1: base; $s2: h
16

 Assembly: lw $t0,1200($t1) add #t0,$s2,$t0 sw $t0,1200($t1) Linguagem de mquina:

Comparar 1a e 3a instrues: 1 bit de diferena. simplicidade favorece regularidade. Computadores modernos: 1. Instrues so representadas como nmeros. 2. Programas podem ser armazenados na memria. Conceito de programa armazenado.
17

Resumo da linguagem at agora:

Programa armazenado: Na memria... Programa de contabilidade. Editor. Compilador. Dados. Texto. Programa em C.

18

3.5 Instrues para decises Computadores: capacidade de tomar decises baseadas nos dados. Linguagens de alto nvel: If. go to. Assembly: beq = if + go to beq regist1, regist2, L1 Se Reg1=Reg2 v para endereo L1. beq = branch if equal. Outra instruo: bne regist1, regist2, L2 Bne = branch if not equal.

Exemplo: montagem de comando if

19

L1:

If (i==j) go to L1; f = g + h; f = f i;

Assumir: f, g, h, i, j $s0, $s1, $s2, $s3, $s4. Cdigo MIPS: beq $s3,$s4,L1 # vai p/ L1 se i=j add $s0,$s1,$s2 # f = g + h sub $s0,$s0,$s3 # f = f i

L1:

Como seria o programa em linguagem de mquina? Estrutura if-then-else If (i==j) f = g + h; else f = g h; Neste caso, ser usada a instruo bne, ao invs da beq. MIPS:
20

Assumir: f, g, h, i, j $s0, $s1, $s2, $s3, $s4. bne $s3,$s4,Else add $s0,$s1,$s2 j Exit Else: sub $s0,$s1,$s2 Exit: # Else, se ij # f=g+h # Vai para Exit # f=g-h;

Salto incondicional: j Endereo. Blocos bsicos: if, for, while, etc. Laos (Loops) Decises: - escolha entre alternativas. - loops. Exemplo: Loop com um array Loop: g = g + A[i]; i = i + j; if (i != h) goto Loop;
21

Supor: g, h, i, j$s1, $s2, $s3, $s4. A um array de 100 elementos. Base do array A: $s5. Lembrar: multiplicar o ndice por 4. Loop: add $t1,$s3,$s3 # $t1 = 2*i add $t1,$t1,$t1 # $t1 = 4*i add $t1,$t1,#s5 # $t1end. A[i] lw $t0,0($t1) # $t0 = A[i] add $s1,$s1,$t0 # g = g + A[i] add $s3,$s3,$s4 # i=i+j bne $s3,$s2,$s4 # if + goto Lao com While: while (save[i] == k) i = i + j; i, j, k $s3, $s4, $s5. Base $s6. Loop: add $t1,$s3,$s3 # $t1 2*i
22

add $t1,$t1,$t1 # $t1 4*i add $t1, $t1,$s6 # $t1 ender. lw $t0,0($t1) # $t0 save[i] bne $t0,$s5,Exit # sai, se falso add $s3,$s3,$s4 # i = i+j j Loop Exit: Teste com menor que: Muitos processadores: instruo especfica de salto com menor que. Instruo extra: slt (set on less than). Exemplo: slt $t0,$s3,$s4 $t0 setado para 1 se $s3<$s4. Registrados $zero (posio 0): o contedo sempre zero.
23

 Combinando slt com beq: salto em menor que. Exemplo: salto em menor que slt $t0,$s0,$s1 bne $t0,$zero,Less Por que no criar uma instruo especfica: simplicidade. Comando Switch/Case Novo instrumento: jr (jump register): Salto incondicional. Pula para o endereo especificado pelo registrador. Geralmente usada juntamente com uma tabela. Para casa: estudar a instruo Switch/Case.

24

3.6 Procedimentos (Procedures) Estruturao de programas. Mais fcil de entender. Reutilizao. Dividir em partes menores. Analogia Agente Secreto Recebe o plano. Adquire os recursos. Executa. Limpa pistas. Devolve o resultado. Procedimentos: Programa: colocar parmetros em lugar acessvel ao procedimento. Transferir controle p/ o procedimento. Garantir recursos de memria nec. execuo do procedimento. Realizar a tarefa.
25

 Colocar o resultado acessvel ao programa chamador. Limpar uso de recursos. Retornar o controle ao chamador. Procedimentos: necessrio... Passagem de parmetros chamador procedimento. Retorno de parmetros procedimento chamador. Endereo do chamador. No MIPS: $a0 - $a3: 4 regs. para argumento: chamador procedimento. $v0 - $v1: 2 regs. para retorno: procedimento chamador. $ra: salva o endereo de retorno do procedimento. Instruo jal (jump and link).
26

 Sintaxe: jal Endereo-do-Procedimento Funcionamento: Pula para o endereo do proced. Salva, no reg. $ra o endereo da instruo seguinte. $ra o endereo de retorno. Nota: endereo de retorno em outras mquinas: pilha. MIPS: PC (contador de programa) Guarda o endereo da instruo atual. Com jal, $ra PC+1. Para retornar de uma sub-rotina: jr $ra

27

 Resumo: Programa chamador guarda os valores dos argumantos em $a0-$a3. Usa a instruo jal X. Procedimento executado. jr $ra. Utilizao de mais registradores Muitas vezes: so necessrios mais que 4 argumentos, retornar mais de 2 argumentos. Onde coloc-los? Mais: destruir todas as pistas qualquer reg. usado pelo procedimento deve ser restaurado. necessrio aumentar o nmero de registradores disponvel, usando a memria. Forma tradicional: usar a pilha. Estrutura do tipo LIFO.
28

 Usada para: Colocar argumentos extras. Colocar retornos extras. Salvar registradores. Variveis locais. Colocar na pilha: push. Retirar da pilha: pull. Pilha em processadores CISC tradicionais automtica. Pilha no MIPS manual. No MIPS: $sp : Stack pointer armazena o topo da pilha. Cresce para dos ends mais altos p/ os mais baixos. Operao de push: Decrementar $sp de 4. Sw reg,0($sp)
29

 Obs: instrues para somar e subtrair e somar regs. a consts. em breve! Exemplo de 1 push: sub $sp, $sp, 4 # $sp pos. vazia!! sw $t0, 0($sp) 2 pushes: sub $sp, $sp, 4 sw $t0, 0($sp) sub $sp, $sp, 4 sw $t1, 0($sp) ou sub $sp, $sp, 8 sw $t0, 4($sp) sw $t1, 0($sp) 3 pushes: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp)
30

Exemplo: Procedimento-folha. No chama outro procedimento Int leaf_example (ing g, int h, int i, int j) { int f; f = (g + h) (i + j); return f } Soluo: g, h, i, j $a0, $a1, $a2, $a3 f $s0 lear_example: sub $sp, $sp, 12 sw $t1, 8($sp) sw $t0, 4($sp) sw $s0, 0($sp)
31

add $t0, $a0, $a1 add $t1, $a2, $t0 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

Nota: no MIPS temos a conveno... $t0-$t9: 10 regs temporrios: no precisam ser preservados.
32

 $s0-$s7: 8 regs de salvamento: preciso ser preservado. Como modificar o programa anterior com esta conveno? Bom: sempre que possvel, usar temporrios como var. locais. Procedimentos Aninhados (no-folha) Mais difceis. Chamam outros procedimentos. Pior: chamam eles mesmos (recursivos). Problemas: Perde argumentos em $a0-$a3. Perde o contedo de $ra. Exemplo. Soluo:

33

 Colocar na pilha, todos os registradores que necessitam ser preservados: $a0-$a3, $t0-$t9, $ra, $s0, ajustar $sp. No retorno: restaurar regs, restaurar $sp. Exemplo: Um procedimento recursivo Fatorial Int fact (int n) { if (n < 1) return (1); else return (n * fact(n 1)); } fact: sub $sp, $sp, 8 sw $ra, 4($sp) sw $a0, 0($sp)
34

slt $s0, $a0, 1 beq $t0, $zero, L1 add $v0, $zero, 1 add $sp, $sp, 8 jr $ra L1: sub $a0, $a0, 1 jal fact lw $a0, 0($sp) lw $ra, 4($sp) add $sp, $sp, 8 mult $v0, $a0, $v0 jr $ra

35

Alocao de espao para novos dados Pilha: tambm usada para guardar variveis locais que no cabem nos registradores. quadro de procedimento ou registro de ativao. $sp: pode ser usado como ponto de referncia para acessar essas variveis. Entretanto: $sp pode mudar, dificultando o acesso s variveis. Se $sp s mudar no incio e no final do procedimento: pode ser usado como referncia. Caso contrrio: usar o registrador $fp (frame pointer).

36

 Variveis em C: Posio de memria. Classe de armazenamento. 2 classes: automtica e esttica. Automticas: locais a um procedimento. Estticas: sobrevivem a um procedimento. Estticas: declaradas fora de procedimentos. $gp (global pointer) seo 3.9.

37

3.7 Alm dos Nmeros Computadores: inicialmente nmeros. Depois: textos. Muito usado: cdigo ASCII.

Notar: maisculas e minsculas. Seria possvel usar instrues vistas at agora (carga de palavra de 32 bits). Entretanto: operao muito comum uma instruo especfica:
38

ld $t0,0($sp) Sb $t0,0($gp)

# ler dados. # escrever dados.

Cada byte ocupa uma posio da memria. Representao de caracteres: (1) 1a posio reservada para o tamanho do mesmo. (2) Uma varivel associada ao string guarda o tamanho. (3) Na ltima posio do string aparece um caracter nulo (ASCII '0'). Usado na linguagem C. Exemplo: rotina para copiar um string para outro. Void strcpy(char x[ ], char y[ ]) { int i; i = 0; while (x[i] = y [i] != 0) /* cp e tst o bit*/ i = i+1; }
39

Supor Bases de x e y: $a0 e $a1. Na rotina: usar $s0 para i strcpy: sub $sp,4 # ajusta pilha sw $s0,4 # salva $s0 (ndice i) add $s0,$zero,$zero # i = 0 L1: add lb add sb add bne lw add jr $t1,$a1,$s0 # end. De y[i] $t2,0(t1) # $t2 y[i] $t3,$a0,$s0 # end de x[i] $t2,0($t3) # x[i] y[i] $s0,$s0,1 #ii+1

$t2,$zero,L1 # Volta se nul $s0,4($sp) $sp,$sp,4 $ra

40

# restaura $s0 # ajusta $sp

 Em C: p/ cpia de strings ponteiros ao invs de arrays (economiza operaes com o ndice i). Nota: Procedimento anterior: folha. Seria melhor, ao invs de usar $s0, usar $t0. No obrigatrio preservar valores de variveis temporrias. Cdigo Unicode: 16 bits. Todas as lnguas vivas. MIPS: String: 4 bytes por palavra. Pilha: 1 byte p/ cada palavra. 3.8) Outros tipos de endereamento 2 outros tipos de instrues: Acesso rpido a constantes. Desvios mais eficientes.
41

Operandos Imediatos ou Constantes Operaes com constantes: muito freqentes: Incremento do ndice de um array. Incremento do contador de um lao. Ajuste do $sp. Exemplo: SPEC... gcc: 52% das ops: imediatos. Spice: 69%. Oferecer verses de instrues em que um dos operandos uma constante. Constante: mantida dentro da prpria instruo (regularidade). Tipo I (I-type): I de Imediato. Tamanho da constante: 16 bits. Instruo addi (add imediato) addi $s0,$s1,10 # $s0 $s1 + 10 Formato da instruo:
42

op 8

rs 29

rt 29

Imediato 4
0000 0000 0000 0100

001000 11101 11101

Instruo slti (set on less than imediato) slti $t0,$s2,$10 # seta $t0 se $s2 < 10 pode ser seguida por bne $t0,$t0,10 para desviar. Princpio de projeto 4: Torne o caso comum mais rpido. Com estas instrues, no preciso carregar primeiramente as constantes em registradores antes de operar. Instruo lui (load upper immediate) Problema: s vezes so necessrias constantes de 32 bits. Soluo: Carregar nos registradores.
43

 Instruo lui: lui $t0, 255 # byte sup. de $t0 255

Exemplo: Carregar este padro em $s0:

0000 0000 0011 1101 0000 1001 0000 0000

lui $s0,61 addi $s0,$s0,2304 Interface Hardware Software MIPS: O montador incrementa a mquina, implementando o que ela no tem. Constantes maiores que 16 bits: o montador automaticamente monta seqncias de adaptao.
44

 Registrador $at: ajuda na montagem de 32 bits (visto depois). Endereamento nos Desvios Condicionais e Incondicionais Desvio incondicional: j 10000 # desvia para 10000 2 6 bits 10000 26 bits

Formato do desvio condicional bne $s0,$s1,Exit #desvia se $s0 $S1 5 16 17 6 bits 5 bits 5 bits Exit 16 bits

Efeito: os 16 bits so um offset: somado prxima posio do PC. J e JAL: no usa end. Relativo.
45

Exemplo: loop while Loop: add add add lw bne add j Exit: Montagem: $t1,$s3,$s3 $t1,$t1,$t1 $t1,$t1,$s5 $t0,0($t1) $t0,$s5,Exit $s3,$s3,$s4 Loop

46

 Obs: H um erro na figura anterior. BEQ e BNE: na verdade, o nmero multiplicado por 4. Quando h um desvio condicional grande: o montador insere um jump. beq bne L2: Pergunte: o end. do j: 26 ou 32 bits? O pulo de nmero de palavras: na verdade o pulo de 28 bits. Onde esto os outros 4 bits? So os 4 MSB do PC. o jump no pode cruzar a fronteira dos 256 Megabytes. Se for necessrio pular: usar o jump para registrador:
47

$s0,$s1,L1 $s0,$s1,L2 j L1

 Colocar o end. no registrador. Usar jr $registrador. Discusso no livro: como obter o programa em assembly, a partir da linguagem de mquina. 3.9 Execuo de um programa 4 passos: C Linguagem de mquina.

48

Compilador Transforma C Assembly Linguagem de alto nvel: maior produtividade. Antigamente: escrito em Assembly. Presentemente: em ling. de alto nvel. Montador Assembly Ling. de mquina. MIPS: O assembly incrementa artificialmente o set de instrues. Pseudo-instrues: No existem na mquina. O montador as cria. Melhora os recursos do Assembly. Pseudo-instruo move: move $t0,$t1 # $t0 $t1 o montador transforma em: add $t0,$zero,$t1
49

Outra pseudo-instruo: blt (branch if less than). o montador substitui esta pseudoinstruo automaticamente por uma combinao de blt/bne. Outras pseudo-instrues: bgt, bge, ble Montador do MIPS: converte um branch fora da faixa em um branch mais um jump. Permite carregar constantes de 32 bits em um registrador, usando combinao de instrues. O MIPS utiliza o registrador $at para uso exclusivo do montador. Montadores: aceitam nmeros em diferentes bases: decimal, binrio, hexadecimal.
0000 0000 1010 1111 1000 0000 0010 0000 = 00af 8020

50

 Montador: transforma o programa em linguagem de mquina em um arquivo objeto combinao de: instrues em linguagem de mquina; dados; informaes necessrias para carregar o programa adequadamente na memria. Exemplo

char A,B,C; void soma(void) { C=A+B; } void main(void){ A=1; B=2; soma(); }
51

 Arquivo .asm:
.module adson4.c .dbfile adson4.c .area text ; IX -> 0,x _soma:: .dbfile adson4.c .dbfunc soma .dbline 5 ; ; char A,B,C; ; ; void soma(void) { ; C=A+B; ldab _A addb _B stab _C .dbline 6 ; } L1: rts ; IX -> 0,x _main:: .dbfunc main .dbline 9 ; ; void main(void){ ; A=1; ldab #1 stab _A .dbline 10 ; B=2; ldab #2 stab _B .dbline 11 ; soma(); /* Call routine to calculate the add numbers */ jsr _soma .dbline 12 ; }
52

L2: rts .area bss _C:: .blkb 1 _B:: .blkb 1 _A:: .blkb 1

Para produzir a verso binria: preciso saber os endereos dos labels (tabela de smbolos). Arquivo objeto: deve conter... Cabealho do arquivo objeto, com tamanho e posio. O segmento de texto que contm o cdigo em linguagem de mquina. O segmento de dados, que contm os dados necessrios. Informao sobre relocao: como os endereos absolutos so redefinidos. Tabela de smbolos: labels nodefinidos, como referncias externas. Informaes para anlise de erros.
XH H 2 areas 5 global symbols M adson4.c
53

A text size 18 flags 0 dbfile adson4.c dbfunc soma 0 dbfunc main A dbline 5 0 dbline 6 9 dbline 9 A dbline A F dbline B 14 dbline C 17 S _main Def000A S _soma Def0000 A bss size 3 flags 0 S _A Def0002 S _B Def0001 S _C Def0000 T 00 00 F6 00 02 FB 00 01 F7 00 00 39 C6 01 F7 R 00 00 00 00 00 03 00 01 00 06 00 01 00 09 00 01 T 00 0D 00 02 C6 02 F7 00 01 BD 00 00 39 R 00 00 00 00 00 02 00 01 00 07 00 01 00 0A 00 00

Ligador Mudana em um programa, que parte de um conjunto: tem que mudar todo o programa? No. S uma parte recompilada. Cada programa j pode estar compilado (em ling. de mquina). Um programa chamado ligador (linker) monta os programas como um nico programa.
54

 Ligador - 3 passos: Colocar os mdulos de cdigo e dados simbolicamente na memria Determinar os endereos dos labels de dados e de instrues. Resolver as referncias externas e internas. Usa, para tal, as informaes do programa objeto. MIPS: convenes para o linker colocar endereos nas memrias:

55

 O ligador monta o arquivo, colocando os endereos certos. Gera um arquivo executvel. Resolver o exemplo no livro: ligao de arquivos hipotticos. Carregador (Loader) Realiza o carregamento do programa na memria. No UNIX: 1) Leitura do cabealho. 2) Criao de espao de cd. e dados. 3) Copiar instr. e dados para a memria. 4) Copiara os par. p/ a pilha (quando houver). 5) Iniciar o SP. 6) Desviar para a rotina de inicializao 3.10 Exemplo Para Juntar as Peas O procedimento swap. Troca dois elementos consecutivos no aray.
56

 Na traduo: 1. Alocar registradores para as variveis. 2. Produzir cdigo para o procedimento. 3. Preservar os registradores nas chamadas. swap (procedimento folha) Swap(int v[ ], int k) { int temp; temp=v[k]; v[k]=v[k+1]; v[k+1]=temp; } base de v, k $a0, $a1; temp $t0. Corpo do procedimento.
add $t1, $a1, $a1 add $t1, $t1, $t1 add $t1, $a0, $t1 lw $t0, 0($t1) lw $t2, 4($t1) sw $t2, 0($t1) sw $t0, 4($t1) jr $ra
57

# # # # # # # #

$t1 2*k $t1 4*k base de v[k] $t0 v[k] $t2 v[k+1] v[k] $t2 v[k+1] $t0 retorna

 Procedimento sort (no-folha)

sort (int v[ ], int n) { int i,j; for (i=0; i < n; i = i+1) { for (j=i-1; j>=0 &&v[j]>v[j-1]) { swap(v,j); } } }

Base v[], n $a0, $a1 i,j $s0,$s1 for externo: move $s0, $zero # i=0 slt $t0,$s0,$a1 # br. se i<m for1tst: beq $t0,$s0,exit1 # corpo do procedimento addi $s1,$s1,1 # i i+1 j for1tst # vai p/ for1tst exit1: Segundo loop for.
58

for (j=i-1; j>=0 &&v[j]>v[j-1])

addi $s1,$s0,-1 # ji-1 for2tst: slti $t0,$s1,0 # j<0? bne $t0,$zero,exit2 #sai add $t1,$s1,$s1 # $t12*i add $t1,$t1,$t1 #$t14*i add $t2,$a0,$t1 # end v[i] lw $t3,0($t2) # $t3 v[j] lw $t4,4($t2) # $t4 v[j+1] slt $t0,$t4,$t3 # deixa loop beq $t0,$zero,exit2 [Corpo do Proced.]

addi $s1,$s1,-1 # j j-1 j for2tst exit2: Corpo do for: swap(v,j); jal swap Seqncia de passagem de parmetros e chamada:
59

 A rotina de chamada utiliza os mesmos parmetros de passagem $a0 e $a1 preciso preserv-los antes de salvlos. Uma opo salvar na pilha, e recuperar depois. Outra opo salvar em outros regs. (usaremos esta). Na chamada: move $s2, $a0 # $s1 $a0 move $s3, $a1 # $s3 $a1 Na volta: move $a0, $s2 # $s1 $a0 move $a1, $s1 # $s3 $a1 Preservao dos Valores dos Registradores de sort sort chamada por outra subrotina. No deve destruir os registradores permanentes utilizados, $s0 a $s3. Dever preservar o $ra.
60

 Na volta, deve-se reverter estas seqncias. Procedimento completo prxima pgina. Comparar: C: 9 linhas. Assembly: 35 linhas. Outro mtodo: inlining. Vantagem: economiza 4 chamadas. Desvantagem: caso seja utilizada por outras rotinas.

61

Programa Clear usando Array e ponteiros. Comparar duas implementaes de uma rotina (para casa).
62