cap3 processador Faíska

Introduo a Organizao de Computadores eLinguagens de Montagem

Ricardo Anido Draft date 15 de Agosto de 2013

Captulo 3

O processador Faska

Neste captulo iniciaremos o estudo mais detalhado do repertrio de instrues do pro-cessador Faska, ilustrando com exemplos de trechos de programas o uso das diversasinstrues. As instrues sero apresentadas usando um descritor no formato de umatabela, como o mostrado na Figura 3, contendo o mnemnico da instruo em destaqueem uma aba (MNE na figura), o nome, a sintaxe do comando correspondente em lin-guagem de montagem, a operao descrita de forma sucinta, e a codificao. O descritorinclui tambm um campo Flags, cujo significado ser introduzido mais adiante, na Seo3.2.1.

MNE

Nome da instruo

Sintaxe Operao Flags Codificao

31 0

Figura 3.1: Formato do descritor de instrues

As instrues sero apresentadas em grupos: transferncia de dados, operaesaritmticas, instrues para controle de fluxo e operaes lgicas.

3.1 Transferncia de dados

Instrues de transferncia de dados so as que permitem a transferncia de dados entredois registradores do processador ou entre a memria e um registrador. Um exemplo de

1

2 CAPTULO 3. O PROCESSADOR FASKA

instruo de transferncia de dados a instruo carrega registrador com valor imedi-ato, que j foi introduzida no captulo anterior. Nesta seo iremos estudar as outrasinstrues para transferncia de dados do repertrio de instrues do Faska.

3.1.1 Transferncia entre registradores

Os operandos para instrues de transferncia entre registradores so sempre dois re-gistradores: o registrador destino (operando mais esquerda) e o registrador fonte (ope-rando mais direita). A operao executada muito simples: o valor do registradorfonte copiado para o registrador destino.

MOV

Carrega registrador com registrador


mov rdest, rfonte rdest rfonte 31 0

00 rdest rfonte

Qualquer dos registradores de propsito geral do Faska (r0 a r15) pode ser usadocomo registrador destino ou fonte.

Exemplo

Endereo Cdigo Programa-------- ------------- -----------------------------------------------

1 ; exemplo de instruo de carga de registrador2 ; com valor constante (endereamento imediato)34 00001000 [00 00 01 05] mov r1,r5 ; instruo codificada em5 ; uma palavra

Antes

00 00 01 05 00100h

000fch

00104h

ff ff ff ffr1Memria

11 11 11 11r5

00 00 01 00ip

Processador

Depois

00 00 01 05 00100h

000fch

00104h

11 11 11 11r1Memria

11 11 11 11r5

00 00 01 04ip

Processador

3.1. TRANSFERNCIA DE DADOS 3

No exemplo acima so mostrados o estado antes e aps a execuo do trecho deprograma em linguagem de montagem, tanto do processador como da memria. Emtodos os exemplos seguintes o mesmo esquema ser utilizado. No processador so mos-trados apenas os registradores importantes para entender a execuo do trecho de pro-grama; os registradores e posies de memria que tiveram seus valores alterados somostrados em tom cinza aps a execuo.

3.1.2 Transferncia da Memria para um registrador

O Faska possui diferentes instrues para transferncia de valores da memria para umregistrador, cada uma com modos de endereamento distintos. As instrues de trans-ferncia da memria para registrador no Faska utilizam trs modos de endereamento:endereamento imediato, endereamento direto e endereamento indireto por registra-dor.

Carrega registrador com endereamento imediato

No endereamento imediato, o valor do operando faz parte do prprio cdigo da ins-truo. Na instruo carrega registrador com endereamento imediato o registradordestino carregado com o valor do operando. E como o valor do operando codificadona prpria instruo, o valor carregado no registrador sempre o mesmo. Em outraspalavras, sempre que uma particular instruo desse tipo for executada, o registradordestino ser carregado sempre com o mesmo valor. Dessa forma, essa instruo utili-zada para carregar um valor constante no registrador destino. Compare o efeito dessainstruo com a instruo carrega registrador com endereamento direto, introduzidano captulo anterior. No endereamento direto, o valor carregado no registrador ovalor corrente de uma posio de memria. Como esse valor pode ser alterado peloprograma, uma mesma instruo carrega registrador com endereamento direto podecarregar diferentes valores no registrador destino a cada vez que executada.


SET

Carrega registrador com endereamento imediato


set rdest, expr8 rdest ext(imd8) 31 0

01 imd8 rdest

set rdest, expr32 rdest imd32

31 0

02 rdest31 0

imd32

O Faska possui duas instrues de carga de registrador com endereamento imedi-ato: uma em que a constante codificada em apenas um byte e uma em que a constante codificada em 32 bits. No caso em que a constante codificada em 32 bits, a instruoocupa duas palavras. Para constantes que podem ser representadas em 8 bits, a instruoutiliza o campo imd8 para armazenar a constante como um inteiro com sinal em com-plemento de dois. Assim, esta forma s permite carregar constantes entre 128 e 127.Como veremos, na programao em linguagem de montagem muitas vezes utilizamosconstantes dentro desse intervalo, o que nos permite utilizar a forma mais econmicacom bastante frequncia. importante notar que todos os 32 bits do registrador destinoso carregados pela instruo set, mesmo na sua forma mais curta. Nesse caso, quandoum valor imd8 positivo carregado em um registrador, os 24 bits mais significativosdo registrador so zerados. Quando o campo imd8 tem um valor negativo, os 24 bitsmais significativos do registrador destino recebem o valor 1, de forma a fazer com queo registrador tenha o valor negativo correto. Ou seja, o bit de sinal do operando imd8 estendido para os bits mais significativos do registrador destino. O fato de que o bit desinal de imd8 estendido para compor o valor de 32 bits mostrado no campo operaodo descritor pela expresso ext(imd8).

Note que na descrio da sintaxe do comando em linguagem de montagem apareceo termo expr8, que representa uma expresso inteira, que quando avaliada deve resultarem um inteiro de 8 bits com sinal.

Exemplo



1 ; exemplo de instruo de carga de registrador2 ; com valor constante (endereamento imediato)34 00001000 [01 ff 03 00] set r3,-1 ; instruo codificada em5 ; uma palavra6

Antes

22 22 22 22r3

Memria

00 00 10 00ip01000h

01004h

01 ff 03 00

Processador

Depois

ff ff ff ffr3

Memria

00 00 10 04ip01000h

01004h

01 ff 03 00

Processador

Exemplo


1 |; outros exemplos de instruo de carga de2 |; registrador com endereamento imediato, com3 |; constantes que no podem ser representadas4 |; em 8 bits.5 |6 00000108 [02 00 09 00] | set r9,400h ; um valor que no pode7 [00 00 04 00] | ; ser representado8 | ; em 8 bits. Cdigo da9 | ; instruo ocupa

10 | ; duas palavras.11 00000110 [02 00 0c 00] | set r12,var1 ; carrega endereo de12 [00 07 00 00] | ; var1. Cdigo tambm13 | ; ocupa duas palavras14 | .org 70000h15 |16 |var1:17 00070000 | .ds 4 ; uma varivel associada18 | ; ao endereo 70000h


Antes

33 33 33 33r9

Memria

55 55 55 55r12

00 00 01 08ip

00110h

00114h

00108h

0010ch

02 00 0c 00

00 07 00 00

00 00 04 00

03 00 09 00

Processador

Depois

00 00 04 00r9

Memria

00 07 00 00r12

00 00 01 18ip

00110h

00114h

00108h

0010ch

02 00 0c 00

00 07 00 00

00 00 04 00

03 00 09 00

Processador

Note que no Exemplo acima, quando o montador avalia a expresso inteira com-posta pelo rtulo var1, durante a montagem do comando set r12,var, o resultado o endereo do rtulo, ou seja, o endereo da varivel associada quele rtulo. esseendereo que montado na segunda palavra da instruo, e portanto esse endereoque carregado como novo valor do registrador r12.

Carrega registrador com endereamento direto

O endereamento imediato s til para carregar o valor de uma constante em umregistrador. Para implementar o conceito de varivel necessrio associar um nomea uma posio especfica na memria. Assim, uma varivel (i, por exemplo) pode serassociada a uma determinada posio da memria (2000h, por exemplo). Toda vez quese quiser acessar uma varivel, faz-se um acesso posio de memria correspondente.

Uma maneira de acessar posies especficas utilizar o chamado endereamentodireto, no qual a instruo contm o endereo da posio de memria que contm o valora ser acessado.

A instruo ld (abreviatura do ingls load) carrega o valor de um registrador como contedo de uma posio de memria, cujo endereo dado na prpria instruo.

LD

Carrega registrador com endereamento direto


ld rdest, expr32 rdest mem[imd32]

31 0

03 rdest31 0

imd32

Note que na descrio da sintaxe do comando em linguagem de montagem apa-rece o termo expr32, que representa uma expresso inteira, que quando avaliada deve


resultar em um inteiro de 32 bits (sem sinal, j que representa um endereo), represen-tada na codificao como imd32. No entanto, na maioria dos casos expr32 na realidadeapenas um rtulo, associado a uma varivel. O montador monta na segunda palavra dainstruo o endereo associado ao rtulo.

Para executar uma instruo ld o processador faz trs acessos memria: umacesso no endereo do ip corrente, para a busca da primeira palavra da instruo; outroacesso no endereo do ip corrente mais quatro, para a busca do endereo do operando(imd32, segunda palavra da instruo); e ainda outro acesso para a busca do valor ope-rando (no endereo retirado no segundo acesso).

Exemplo


1 | ; exemplo de instruo ld2 | ; cdigo ocupa duas palavras3 |4 00000100 [03 00 0a 00] | ld r9,cont5 [00 00 20 00] |6 | ...7 |8 | .org 2000h9 | cont:

10 00002000 | .ds 4 ; uma varivel associada11 ; ao endereo 2000h

Antes

22 22 22 22 02000h

0fffch

02004h

55 55 55 55r10

Memria

00 00 01 00ip

00100h

00104h00 00 20 00

03 00 0a 00

Processador

Depois

22 22 22 22 02000h

0fffch

02004h

22 22 22 22r10

Memria

00 00 01 08ip

00100h

00104h00 00 20 00

03 00 0a 00

Processador

Carrega registrador com endereamento indireto por registrador

No modo de endereamento indireto por registrador o endereo do operando dadoem um registrador, ao invs de ser um valor constante, codificado na instruo, comono endereamento direto. Na linguagem de montagem, utilizaremos para a instruo decarga de registrador com endereamento indireto por registrador o mesmo mnemnicold j utilizado anteriormente, mas indicaremos o modo de endereamento distinto pelagrafia do operando fonte. Enquanto na instruo ld com modo de endereamento diretoo operando fonte um rtulo (no caso geral, qualquer expresso inteira), na instruo


ld com modo de endereamento indireto por registrador o operando fonte o nome deum registrador entre parnteses. Essa conveno de utilizar o mesmo mnemnico paraduas instrues distintas apenas uma convenincia para o programador; importantenotar no entanto que para o processador o que existe so duas instrues distintas, comcodificaes diferentes.

LD

Carrega registrador com endereamento indireto por registrador


ld rdest, (rfonte) rdest mem[rfonte] 31 0

04 rdest rfonte

Exemplo


1 |; instruo carrega registrador com2 |; endereamento indireto por registrador3 |; cdigo da instruo ocupa uma palavra4 |5 000001ac [04 00 06 05] | ld r6, (r5)6 |7

Antes

00 00 00 01 0300ch

03008h

03010h

00 00 30 0cr5

Memria

ff ff ff f0r6

00 00 01 acip

001ach

001b0h

04 00 06 05

Processador

Depois

00 00 00 01 0300ch

03008h

03010h

00 00 30 0cr5

Memria

00 00 00 01r6

00 00 01 b0ip

001ach

001b0h

04 00 06 05

Processador

Carrega registrador com endereamento indireto por registrador mais uma constante

A instruo carrega registrador com endereamento indireto por registrador mais umaconstante na verdade a mesma instruo que carrega registrador com enderea-


mento indireto por registrador. Apresentamos as duas instrues separadamente ape-nas como forma mais didtica de introduzir o modo de endereamento indireto porregistrador mais constante. Nesse novo modo de endereamento o operando fonte uma expresso de adio, entre parnteses, em que um termo o nome de um regis-trador e o outro termo uma expresso constante com valor entre 128 e 127. O termoconstante codificado no campo imd8; o endereo efetivo calculado efetuando a adiodo valor do registrador com o valor de imd8 com o sinal estendido. O fato de que o bit desinal de imd8 estendido para compor o valor de 32 bits mostrado no campo Operaodo descritor pela expresso ext(imd8).

LD

Carrega registrador com endereamento indireto por registrador mais umaconstante


ld rdest, (rfonte + expr8)rdest

mem[rfonte + ext(imd8)]

31 0

04 imd8 rdest rfonte

Exemplo


1 |; instruo carrega registrador com2 |; endereamento indireto por registrador3 |; mais uma constante.4 |; cdigo da instruo ocupa uma palavra5 |6 00000200 [04 08 02 03] | ld r2,(r3+8)7 00000204 [04 fc 06 05] | ld r6,(r5-4)


Antes

00 00 40 04r5

Memria

55 55 55 55r6

00 00 02 00ip

99 99 99 99 04000h

03ffch

04004h

00200h

00204h

04 08 02 03

Processador

22 22 22 22r2

00 00 2f f8r3

77 77 77 77 03000h

02ffch

03004h

04 fc 06 05 Depois

00 00 40 04r5

Memria

99 99 99 99r6

00 00 02 08ip

99 99 99 99 04000h

03ffch

04004h

00200h

00204h

04 08 02 03

Processador

77 77 77 77r2

00 00 2f f8r3

77 77 77 77 03000h

02ffch

03004h

04 fc 06 05

interessante notar que os modos de endereamento indireto por registrador eindireto por registrador mais uma constante so implementados pela mesma instru-o, com cdigo 04h. Na verdade, a execuo desta instruo do processador sempresoma o valor do campo imd8 ao valor do registrador destino para encontrar o valor doendereo efetivo do operando. Quando imd8 zero resulta no modo de endereamentoindireto por registrador; quando imd8 diferente de zero resulta no modo de endere-amento indireto por registrador mais uma constante.

Transferncia de bytes entre a memria e um registrador

Como muito comum a necessidade de manipular valores de 8 bits (especialmente ca-racteres), o Faska inclui tambm instrues para carregar um byte da memria em umregistrador. Na instruo Carrega registrador com byte da memria, apenas um byte carregado da memria para o registrador destino. O byte carregado colocado nos 8 bitsmenos significativos do registrador destino; os 24 bits mais significativos do registradorso zerados.

O mnemnico utilizado pelo montador ldb; como no caso da instruo ld, hdois modos de endereamento possveis: direto e indireto por registrador mais umaconstante.


LDB

Carrega registrador com byte da memria


ldb rdest, expr32 rdest mem8[imd32]

31 0

07 rdest31 0

imd32

ldb rdest, (rfonte + expr8)rdest

mem8[rfonte + ext(imd8)]

31 0

08 imd8 rdest rfonte

Novamente, interessante notar que os modos de endereamento indireto porregistrador e indireto por registrador mais uma constante so implementados pelamesma instruo, com cdigo 08h. Como comentado anteriormente a execuo destainstruo sempre soma o valor do campo imd8 ao valor do registrador destino para en-contrar o valor do endereo efetivo do operando, de fomra que o modo de enderea-mento indireto por registrador pode ser entendido como um caso especial do modode endereamento indireto por registrador mais uma constante, quando a constantetem valor zero.

Exemplo


1 | ; instruo carrega registrador com byte da2 | ; memria3 |4 00000200 [07 00 0d 00] | ldb r13,carac+7 ; carrega byte cujo5 [00 00 04 0b] | ; endereo carac+76 |7 00000204 [08 00 01 02] | ldb r1,(r2) ; r2 tem endereo do8 | ; byte que queremos9 | ; carregar em r1

10 |11 00000208 [08 ff 0c 02] | ldb r12,(r2-1) ; r2-1 tem endereo do12 | ; byte que queremos13 | ; carregar em r1214 | ...15 |16 | .org 4004h17 | carac: ; uma varivel que18 | ; contm uma sequncia19 | ; de bytes (caracteres)20 00004004 [55 56 57 58] | .db U, V, W, X21 00004008 [61 62 63 64] | .db a, b, c, d


Antes

64 63 62 61

55 56 57 58

04008h

04004h

0400ch

11 11 11 11r1

Memria

00 00 40 06r2

aa aa aa aar13

00 00 02 00ip

00204h

00200h07 00 0d 00

00 00 40 0b

08 00 01 02

Processador

00208h

0020ch

bb bb bb bbr12

00210h

08 00 01 02

Depois

64 63 62 61

55 56 57 58

04008h

04004h

0400ch

00 00 00 63r1

Memria

00 00 40 06r2

00 00 00 64r13

00 00 02 10ip

00204h

00200h07 00 0d 00

00 00 40 0b

08 00 01 02

Processador

00208h

0020ch

00 00 00 62r12

00210h

08 ff 0c 02

3.1.3 Transferncia de um registrador para a memria

As instrues de transferncia de um registrador para memria permitem armazenar ovalor de um registrador em uma posio de memria, efetuando a operao inversa dasinstrues de carga de registrador. No Faska, estas instrues utilizam o mnemnicost (do ingls store, armazenar) e possui duas variantes, correspondentes aos modos deendereamento direto e indireto por registrador.

Armazena registrador em memria

ST

Armazena de registrador na memria


st (rdest + expr8), rfontemem[rdest+ext(imd8)]

rfonte

31 0

05 rdest rfonte

st (rdest), expr32 mem[imd32] rfonte

31 0

06 rfonte

31 0

imd32

Exemplo



1 |; exemplos de instruo armazena registrador na2 |; memria3 |4 00000200 [05 00 00 07] | st var,r7 ; armazena registrador5 [00 00 10 00] | ; r7 na varivel var6 |7 |8 00000204 [06 00 04 03] | st (r4),r3 ; r4 tem endereo9 | ; onde queremos

10 | ; armazenar r311 |12 | .org 1000h13 |var: ; uma varivel montada14 00001000 | .ds 4 ; no endereo 1000h

Antes

00 00 00 00

ff ff ff ff

01004h

01000h

01008h

ff ff ff ffr3

Memria

00 00 10 04r4

00 00 00 00r7

00 00 03 14ip

00314h

00318h

05 00 00 07

00 00 10 00

06 00 04 03

Processador

0031ch

00320h

Depois

ff ff ff ff

00 00 00 00

01004h

01000h

01008h

ff ff ff ffr3

Memria

00 00 10 04r4

00 00 00 00r7

00 00 03 20ip

00314h

00318h

05 00 00 07

00 00 10 00

06 00 04 03

Processador

0031ch

00320h


Antes

48 47 46 45

44 43 42 41

02004h

02000h

02008h

00 00 00 67r2

Memria

00 00 20 04r5

00 00 00 55r4

00 00 01 08ip

00108h

0010ch

09 00 00 04

00 00 20 02

0a 00 05 02

Processador

00110h

00114h

Depois

48 47 46 67

44 55 42 41

02004h

02000h

02008h

00 00 00 67r2

Memria

00 00 20 04r5

00 00 00 55r4

00 00 01 14ip

00108h

0010ch

09 00 00 04

00 00 20 02

0a 00 05 02

Processador

00110h

00114h

Podemos agora ver como traduzir, para linguagem de montagem, um pequeno tre-cho de programa escrito em linguagem C exemplificando o uso de variveis e comandosde atribuio:

Exemplo Traduzir o trecho abaixo, em linguagem C, contendo alguns comandos deatribuio, para linguagem de montagem do Faska.

1 // Trecho de programa em C23 #define TAMANHO 25645 int a,b;6 char c;7 ...89 a = TAMANHO;10 b = a;11 c = a;


1 ; traduo para linguagem de montagem2 ; do trecho de programa acima34 TAMANHO .equ 25656 ; reserva espao para as variveis7 .org 20h8 a: .ds 49 b: .ds 4

10 c: .ds 11112 .org 100h13 set r0, TAMANHO ; r0 usado como auxiliar14 st a, r0 ; armazena valor na varivel a15 st b, r0 ; armazena valor na varivel b16 set r1, a ; r1 usado como auxiliar; note17 ; que r0 poderia ser reutilizado18 stb c, r1 ; armazena caractere na varivel c19

3.1.4 Ordem de bytes na memria

Como vimos, a memria do computador vista como um vetor de bytes, em que osendereos de memria representam os ndices desse vetor. Ou seja, o primeiro byte damemria tem endereo 0, o segundo byte da memria tem endereo 1, o terceiro bytetem endereo 2 e assim por diante. Muitas vezes tambm consideramos a memriacomo uma sequncia de palavras. Mas como o endereamento da memria por by-tes, quando consideramos a memria como uma sequncia de palavras continuamos autilizar os endereos dos bytes individuais. Assim, para um processador com palavrastm 32 bits, como o Faska, a primeira palavra est no endereo 0, a segunda palavra noendereo 4 (e no 1), a terceira palavra est no endereo 8 (e no 2), e assim por diante.Isso fica tambm evidente nas figuras que temos usado para representar o contedo damemria, como mostrado na figura abaixo, que mostra duas palavras presentes nos en-dereos de memria 0200h e 0204h.

Memria

200h

204h

33 22 11 00

77 66 55 44

208h

1fch

Vamos agora examinar com maior detalhe a ordem em que os bytes de uma palavraso armazenados na memria. Quando por exemplo valor de um registrador trans-ferido para ou da memria, um processador pode considerar os bytes que formam a


palavra a ser transferida em pelo menos duas ordens distintas: o byte de memria quetem endereo mais baixo pode conter (i) o byte mais significativo do registrador ou (ii) obyte menos significativo da palavra.

Memria031 81725

end_inicio+4

end_inicio+8

end_inicio+12

end_inicio

Registrador

Big-endian

Memria

031 81725

end_inicio+4

end_inicio+8

end_inicio+12

end_inicio

Registrador

Little-endian

A ordem (i) chamada em ingls de big-endian, e ordem (i) chamada de little-endian. Esses nomes so referncias ao livro Viagens de Gulliver, de Jonathan Swift, emque dois reinos esto em guerra por divergirem sobre como deve ser comido um ovoquente: a partir do extremo mais fino ou do extremo mais grosso do ovo.

Tal como no conto de Swift, a ordem escolhida pelo processador no importa, poiscomo o processador sempre armazena e l os bytes da memria na mesma ordem, am-bas as ordens so funcionalmente equivalentes, embora haja vantagens e desvantagensde cada uma em relao implementao em hardware. Mas como processadores dis-tintos utilizam ordens distintas, quando necessria a transferncia de informao entreum computador e outro importante que se conhea a ordem utilizada em ambos osprocessadores envolvidos para que a informao seja corretamente recebida.

A figura abaixo mostra um exemplo de duas palavras, de valores 33221100h e77665544h, armazenadas em endereos consecutivos da memria (respectivamente 200he 204h), utilizado as ordens little-endian e big-endian.


Memria (em palavras)

Memria (em bytes)

Little-endian

Memria (em bytes)

200h

204h

33 22 11 00

77 66 55 44

208h

1fch

200h

201h

44

22

00

33

11

55

66

77

202h

203h

204h

205h

206h

207h

208h

1ffh

200h

201h

77

11

33

00

22

66

55

44

202h

203h

204h

205h

206h

207h

208h

1ffh

Big-endian

Note que o Faska utiliza a ordem little-endian.

3.2 Instrues aritmticas

No grupo das instrues aritmticas encontramos instrues para somar, subtrair, mul-tiplicar e dividir nmeros inteiros. Nesta seo estudaremos apenas as instrues parasomar e subtrair; multiplicao e diviso sero apresentadas mais adiante.

No Faska as instrues de adio e subtrao tm sempre como operando des-tino um registrador; o segundo operando pode ser um outro registrador ou um valorimediato codificado em 8 bits (inteiro em complemento de dois).

3.2.1 Adio

ADD

Adio


add rdest, expr8 rdest rdest + ext(imd8) CNVZ31 0

10 imd8 rdest

add rdest, rfonte rdest rdest + rfonte CNVZ31 0

11 rdest rfonte

3.2. INSTRUES ARITMTICAS 19

Bits de estado

Note que na instruo add pela primeira vez o campo Flag do descritor de instruono est vazio, e contm quatro letras. Essas letras representam bits de estado (em ingls,flags). No Faska os bits de estado so:

C: vai-um (carry). Ligado se operao causou vai-um (carry-out) ou vem-um (carry-in), desligado caso contrrio.

Z: zero. Ligado se o resultado foi zero, desligado caso contrrio.

N: sinal. Cpia do bit mais significativo do resultado; considerando aritmtica comsinal, se N igual a zero, o resultado maior ou igual a zero. Se N igual a 1, resultado negativo.

V: overflow. Ligado se ocorreu estouro de campo; calculado como o ou-exclusivoentre o vem-um e o vai-um do bit mais significativo do resultado.

No descritor de instrues o campo Flag indica quais os bits de estado so afetadospela instruo; no caso da instruo add, todos os bits so afetados. Um bit de estadoguarda a informao do resultado da ltima instruo executada que o afetou. Isto , seuma instruo no afeta um determinado bit de estado, este permanece com o mesmovalor anterior execuo da instruo. Bits de estado no so alterados por operaesde transferncia de dados.

Os bits de estado so armazenados em um registrador especial no Faska, que no acessvel atravs de instrues de carga. Nas figuras dos exemplos, esse registradorespecial mostrado com o nome flags. Veremos mais adiante como os bits de estado soutilizados para controlar o fluxo de execuo de um programa.

Exemplo


1 |; exemplos de adio com endereamento2 |; imediato e entre registradores3 |4 00030000 [10 01 04 00] | add r4,1 ; adio com valor imediato5 | ; instruo ocupa uma6 | ; palavra7 |8 |9 00030004 [11 00 01 02] | add r1,r2 ; adio de dois

10 | ; registradores11 | ; instruo ocupa uma12 | ; palavra


00 03 00 00ip

Antes

80 00 11 11r1 Memria

80 00 00 abr2

00 ff ff ffr4 30000h

30004h

10 01 04 00

11 00 01 02

Processador

30008h

... 0 0 0 0flagsC N Z V

00 03 00 08ip

Depois

00 00 11 bcr1 Memria

80 00 00 abr2

01 00 00 00r4 30000h

30004h

10 01 04 00

11 00 01 02

Processador

30008h

... 1 0 0 1flagsC N Z V

3.2.2 Subtrao

SUB

Subtrao


sub rdest, expr8 rdest rdest ext(imd8) CNVZ31 0

12 imd8 rdest

sub rdest, rfonte rdest rdest rfonte CNVZ31 0

13 rdest rfonte

Exemplo


1 |; exemplos de adio com endereamento2 |; imediato e entre registradores3 |4 00050000 [12 01 06 00] | sub r6,1 ; subtrao com valor5 | ; imediato, instruo6 | ; ocupa uma palavra7 |8 |9 00050004 [13 00 08 07] | sub r8,r7 ; subtrai registrador de

10 | ; registrador11 | ; instruo ocupa uma12 | ; palavra

3.2. INSTRUES ARITMTICAS 21

00 05 00 00ip

Antes

10 00 00 00r6 Memria

ff ff ff ffr7

ff ff ff ffr8 50000h

50004h

12 01 06 00

13 00 08 07

Processador

50008h

... 0 0 0 0flagsC N Z V

00 05 00 08ip

Depois

0f ff ff ffr6 Memria

ff ff ff ffr7

00 00 00 00r8 50000h

50004h

12 01 06 00

13 00 08 07

Processador

50008h

... 0 0 1 0flagsC N Z V

Exerccio 3.1 Escrever um trecho de programa em linguagem de montagem que imple-mente o seguinte comando de atribuio em C:

1 var a, b, c: integer;23 ...45 a = b + c - 2;67 ...


Soluo

1 ; traduo para linguagem de montagem2 ; do trecho para implementar a = b + c - 234 ; reserva espao para as variveis inteiras a, b e c5 a: .ds 46 b: .ds 47 c: .ds 48 ...9 ld r0,b ; r0 e r1 so usados como auxiliares

10 ld r1,c11 add r0,r1 ; r0 agora tem b+c12 sub r0,213 st a,r0 ; e armazena o resultado

3.3 Instrues de desvio

At agora, em todos os exemplos mostrados as instrues so executadas em sequnciaestrita das suas posies da memria, ou seja, o valor do registrador ip sempre incre-mentado de quatro a cada instruo. Se no houver uma forma de fazer o valor de ipvariar de maneira no sequencial, fica impossvel de implementar repeties como os co-mandos for e while em C ou Pascal. Para controlar o fluxo de execuo do programa, sousadas instrues de desvio, que alteram o valor do registrador interno ip. Instruesde desvio podem ser condicionais ou incondicionais.

3.3.1 Desvio incondicional

A execuo da instruo de desvio incondicional tem apenas um operando bastantesimples: o valor do registrador ip modificado para o valor do operando. Ou seja, ovalor do operando copiado para o registrador ip, fazendo com que a prxima instru-o a ser executada tenha o endereo do operando, alterando dessa forma a execuopuramente sequencial de instues vista at agora. H duas instrues de desvio in-condicional: uma que codificada em duas palavras, com a segunda palavra contendoo valor do endereo alvo do desvio, e uma instruo codificada em uma palavra, naqual o endereo alvo dado em um registrador. O mnemnico utilizado para as duasinstrues jmp, do ingls jump (salto).


Antes

00 00 04 03

04004h

04000h

ff ff ff ffr0

Memria

33 33 33 33r3

44 44 44 44r4

00 00 40 00r10

00 00 02 00ip00300h

00304h

01 01 00 00

21 00 0a 00

00 00 03 04

Processador

00308h

0030ch

Depois

00 00 04 03

04004h

04000h

00 00 00 01r0

Memria

33 33 33 33r3

33 33 33 33r4

00 00 40 00r10

00 00 40 04ip00300h

00304h

01 01 00 00

21 00 0a 00

00 00 03 04

Processador

00308h

0030ch

3.3.2 Desvios condicionais

Instrues de desvio condicional so mais interessantes. Elas executam ou no o desviodependendo do valor de um ou mais de bits de estado, que como j vimos so alteradospela execuo de algumas instrues, em particular as instrues aritmticas.

No Faska, as operaes de desvio condicional so codificadas em uma palavra. Oclculo do endereo alvo do desvio diferente do caso do desvio incondicional, em queo endereo alvo um valor absoluto, dado na segunda palavra da instruo. No casodas operaes de desvio condicional, o processador utiliza o valor codificado no campoimd8 para calcular o endereo alvo. O endereo alvo calculado de forma relativa aovalor corrente do registrador ip: o valor do campo imd8, transformado em um inteirode 32 bits, com sinal, adicionado ao valor corrente de ip para determinar o novo valorde ip.

Jcond

Desvio condicional


jcond expr8 ip ip+ ext(imd8) 31 0

xx imd8

No descritor, a sintaxe dada como jcond expr8 pois no caso geral o operando uma expresso inteira cujo resultado deve ser possvel armazenar em oito bits; mas nagrande maioria dos casos a expresso composta de apenas um rtulo. O montadormonta, no campo imd8, o valor da expresso (ip endereo alvo). O valor do campoimd8 interpretado como um inteiro com sinal, de forma que o endereo alvo pode sermenor ou maior do que o ip corrente, fazendo com que o fluxo do programa tenha um


salto para trs (endereo alvo menor que o ip corrente) ou para frente (endereo alvomaior que ip o corrente), respectivamente.

Instr. Nome Cond. Codif.jc desvia se vai-um (menor sem sinal) C=1 22hjnc desvia se no vai-um (maior ou igual sem sinal) C=0 23hjz desvia se zero Z=1 24hjnz desvia se diferente de zero Z=0 25hjo desvia se overflow V=1 26hjno desvia se no overflow V=0 27hjs desvia se sinal igual a um N=1 28hjns desvia se sinal igual a zero N=0 29hjl desvia se menor (com sinal) N6=V 2ahjle desvia se menor ou igual (com sinal) Z=1 ou N6=V 2bhjg desvia se maior (com sinal) Z=0 e N=V 2chjge desvia se maior ou igual (com sinal) N=V 2ehja desvia se acima (maior sem sinal) C=0 e N=V 2fh

Exemplo


1 | ; exemplos de desvios condicionais2 |3 | .org 500h4 00000500 [12 01 08 00] | sub r8,1 ; uma instruo montada5 | ; no endereo 300h6 | ; ocupa uma palavra7 |8 |9 00000504 [24 04 00 00] | jz final ; instruo de desvio

10 | ; condicional11 | ; codificao ocupa uma12 | ; palavra13 00000508 [01 64 08 00] | set r8,100 ; esta instruo 14 | ; executada se o resultado15 | ; da subtrao for16 | ; diferente de zero17 | final:18 0000050c [00 00 05 06] | mov r5,r6 ; esta instruo a19 | ; prxima a ser executada20 | ; aps o desvio se o21 | ; resultado da subtrao22 | ; for diferente de zero


Antes

55 55 55 55r5

Memria

66 66 66 66r6

00 00 00 01r8

00 00 05 00ip00500h

00504h

12 01 08 00

24 04 00 00

01 64 08 00

00 00 05 06

Processador

00508h

0050ch

00510h

Depois

66 66 66 66r5

Memria

66 66 66 66r6

00 00 00 00r8

00 00 05 10ip00500h

00504h

12 01 08 00

24 04 00 00

01 64 08 00

00 00 05 06

Processador

00508h

0050ch

00510h

As instrues de desvio condicional so usadas para codificar comandos de con-trole de fluxo em linguagens de alto nvel, como if-then-else, for, while e switch. Por exem-plo, o trecho abaixo escrito em C:

1 int a,b;23 ...45 if (a==b)6 a=a+b;7 else8 b=a+b;9 ...

pode ser traduzido em linguagem de montagem do Faska da seguinte maneira:

1 ; aloca variveis inteiras2 ; note que podem armazenar valores com ou sem sinal3 ; o "tipo" deve ser interpretado pelo programador4 a: .ds 45 b: .ds 467 ...89 ld r0,a ; if (a==b)10 ld r1,b11 cmp r0,r112 jnz else13 add r0,r1 ; a=a+b14 st a,r015 jmp final_if16 else:17 add r1,r0 ; b=a+b18 st b,r119 final_if:20 ...

A instruo jz, usada para testar igualdade, obviamente pode ser utilizada para


comparaes tanto entre valores inteiros com sinal como entre valores inteiros sem sinal.Note no entanto que a comparao entre um nmero x sem sinal e um nmero y comsinal mais complicada, pois tem sentido somente para valores positivos de y.

As instrues jl, jle, jg e jge (em ingls, respectivamente jump if less e jump lessor equal, jump if greater e jump if greater or equal) devem ser usadas na comparao n-meros inteiros com sinal; as instrues jc, jnc e ja (em ingls, respectivamente jump ifcarry, jump if not carry e jump if above) devem ser usadas na comparao de nmeros intei-ros sem sinal. Por exemplo, o trecho trecho em linguagem C abaixo, que usa comparaoentre nmeros com sinal:

1 int x,y;23 ...45 if (x>=y)6 y=y+2;7 else8 x=x+2;9 ...

pode ser traduzido em linguagem de montagem do Faska da seguinte maneira:

1 ; aloca variveis inteiras2 x: .ds 43 y: .ds 445 ...67 ld r0,x ; if (x>=y)8 ld r1,y9 cmp r1,r0

10 jg else ; se y>x executa ramo do else11 add r0,2 ; x=x+212 st x,r013 jmp final_if14 else:15 add r1,2 ; y=y+216 st y,r117 final_if:18 ...

Note que se as variveis do trecho de programa C acima fossem do tipo unsignedint, ou seja, se as variveis representassem valores inteiros sem sinal, a instruo dedesvio condicional da linha 10 da traduo para linguagem de montagem deveria serja ao invs de jg.

Como mais um exemplo de traduo de linguagem C para linguagem de monta-gem, vamos traduzir um trecho que inclui um comando for:


1 int i,a,b;23 ...45 for (i=0;i=100? caso verdadeiro, finaliza14 corpo_for:15 ld r1,a ; bloco de comandos do for tem apenas o16 ld r2,b ; comando de atribuio17 add r1,r218 st a,r1 ; a=a+b19 jmp teste_for ; terminou o bloco, executa novamente o20 ; teste para verificar se continua21 final_for:22 ...

Vrias otimizaes so possveis, se notarmos que no necessrio, dentro do laodo comando for, armazenar o valor das variveis na memria com um comando st paralogo em seguida carregar o mesmo valor, no mesmo registrador, com um comando ld.Assim, podemos retirar do lao os comando de acesso memria, carregando antesdo lao os registradores correspondentes, e armazenando os novos valores na memriasomente aps o lao. Dessa forma, as instrues que compem o bloco de comandos dofor trabalham apenas com registradores, o que torna a execuo muito mais eficiente:


1 ; aloca variveis inteiras2 i: .ds 43 a: .ds 44 b: .ds 456 ...7 inicio_for:8 set r0,09 ld r1,a ; prepara para os

10 ld r2,b ; comando de atribuio11 teste_for:12 cmp r0,100 ; verifica se executa o bloco de comandos do for13 jge final_for ; i>=100? caso verdadeiro, finaliza14 corpo_for:15 add r1,r216 jmp teste_for ; terminou o bloco, executa novamente o17 ; teste para verificar se continua18 final_for:19 st i,r0 ; atualiza valor de i20 st a,r1 ; atualiza valor de a21 ...

A codificao dos desvios condicionais no Faska, que assim como processadoresreais utiliza endereamento relativo, traz uma complicao, j que o endereo alvo nopode estar distante mais do que 127 bytes adiante ou128 bytes antes do ponto correntede montagem. Se um desvio condicional no puder ser montado porque o endereo alvoficou mais distante do que o permitido, necessrio inverter a condio usada e utilizardois desvios, um deles incondicional. Por exemplo, suponha que no trecho abaixo ortulo muito_longe estiver muito distante do desvio condicional, de tal forma que adistncia relativa no possa ser representada no campo imd8 da instruo jnc:

1 sub r2, r12 jnc muito_longe3 add r0, r34 ...5 muito_longe:6

O montador indicar um erro, informando que no possvel montar o programa.Podemos re-escrever o trecho invertendo a lgica do desvio condicional (de jnc parajc) e utilizando um desvio incondicional adicional, eliminando o problema:


1 sub r2, r12 jc bem_perto3 jmp muito_longe4 bem_perto:5 add r0, r36 ...7 muito_longe:8

Mas note que este praticamente o nico caso em que dois desvios precisam serescritos sequencialmente; normalmente isto no necessrio, e dois desvios em sequn-cia podem indicar uma construo errada, que pode ser melhorada para utilizar apenasum desvio.

Vamos escrever um trecho de programa que, dados dois nmeros inteiros sem sinalem r1 e r2, coloque em r1 o menor valor e em r2 o maior valor.

1 ordena:2 mov r0, r1 ; vamos usar r0 como rascunho3 sub r0, r2 ; valor de r1 maior que r2?4 jc final ; no --- nada a fazer5 mov r0, r1 ; troca r1 com r26 mov r1, r2 ; usando r07 mov r2, r0 ; como temporrio8 final:9 ...

Vamos escrever um trecho de programa que coloque no registrador r0 o maiorvalor entre r1, r2 e r3. Suponha que os registradores contenham nmeros inteiros comsinal.

1 maior:2 mov r4,r1 ; usando r4 como rascunho3 sub r4,r2 ; compara r1 e r24 jge um ; desvia se r1 maior5 mov r4,r2 ; guarda maior valor em r46 mov r0,r2 ; e em r07 jmp outro8 um:9 mov r4,r1 ; guarda maior valor em r410 mov r0,r1 ; e em r011 outro:12 sub r4,r3 ; compara maior entre r1 e r2 com r313 jge final ; r3 menor, r0 j tem maior valor14 mov r0,r3 ; maior e r315 final:16 ...


3.3.3 Nova instruo aritmtica: comparao

O exemplo acima, que deveria ser bem simples, ficou um pouco mais extenso e com-plicado porque a instruo de subtrao usada para comparar os registradores altera ovalor do registrador destino. Isto faz com que precisemos usar registradores auxiliaresque devem ser reinicializados aps cada subtrao. Como comparao uma operaorelativamente frequente, ela definida como uma instruo primitiva na maioria dosprocessadores. Esta nova instruo bastante semelhante instruo sub, com a dife-rena de que o registrador destino no alterado. Quer dizer, a subtrao efetuada,os bits de estado so modificados correspondentemente, mas o resultado no colocadono registrador destino, que permanece com o valor inicial.

CMP

Comparao


cmp rdest, expr8 rdest ext(imd8) CNVZ31 0

14 imd8 rdest

cmp rdest, rfonte rdest rfonte CNVZ31 0

15 rdest rfonte

Vamos re-escrever a soluo para o Exemplo 3.3.2 com a instruo cmp.

1 maior:2 mov r0,r1 ; assume que r1 e o maior3 cmp r0,r2 ; compara r1 e r24 jge outro ; desvia se r1 maior5 mov r0,r2 ; r2 maior, guarda em r06 outro:7 cmp r0,r3 ; compara maior entre r1 e r2 com r38 jge final ; r0 j tem o maior valor9 mov r0,r3 ; maior r3

10 final:11 ... ; final do trecho

Exemplo Escreva um trecho de programa que determine qual o maior valor de uma ca-deia de nmeros de 32 bits, sem sinal, cujo endereo inicial dado em r2. Inicialmente,r3 contm o nmero de valores presentes na cadeia; suponha que r3 > 0. Ao final dotrecho, r0 deve conter o valor mximo e r1 deve conter o endereo do valor mximo.


1 inicio:2 mov r1,r2 ; guarda apontador para incio3 mov r0,(r1) ; e valor mximo corrente4 proximo:5 add r2,4 ; avana ponteiro para prximo elemento6 sub r3,1 ; um elemento a mais verificado7 jz final ; terminou de verificar toda a cadeia?8 ld r4,(r2) ; no, ento toma mais um valor9 cmp r0,r4 ; compara com mximo corrente10 jnc proximo ; desvia se menor ou igual11 mov r2,r1 ; achamos um maior, guarda novo apontator12 mov r0,r4 ; e novo mximo13 jmp proximo ; e continua a percorrer a cadeia14 final:15 ... ; final do trecho

Note que o registrador que percorre a cadeia, r2, incrementado de quatro a cadaelemento verificado, pois cada elemento ocupa quatro bytes.

Exemplo Escreva um trecho de programa para mover um bloco de palavras de mem-ria da posio apontada por r1 para a posio apontada por r2. O tamanho do bloco(nmero de palavras) que deve ser movido dado em r3.

1 ; primeira verso...2 ; move bloco de palavras3 ; entrada:4 ; r1: endereo inicial do bloco5 ; r2: endereo para onde o bloco deve ser movido6 ; r3: tamanho do bloco, em palavras de 32 bits7 MoveBloco:8 ld r0,(r1) ; copia palavra9 st (r2),r0 ; na nova posio10 add r1,4 ; avana ponteiros11 add r2,412 sub r3,1 ; verifica se chegou ao final do bloco13 jnz MoveBloco ; no, continua movendo14 ... ; aqui quando terminou de mover o bloco

Infelizmente esta soluo simples no funciona para todos os casos. A Figura 3.2ilustra de forma esquemtica as configuraes possveis para este problema, depen-dendo do tamanho do bloco e de suas posies inicial e final. Na figura, os endereos damemria crescem da esquerda para a direita.

A soluo apresentada funciona perfeitamente para os casos (a) e (b) da Figura 3.2,quando no h interseo entre a posio original e a posio final do bloco, e funcionatambm para o caso (d).

Mas no caso (c) a cpia das primeiras palavras destri o contedo do bloco ori-ginal. Neste caso, necessrio fazer a cpia do final do bloco para o comeo, comoesquematizado na Figura 3.3.


r2(destino)

r1(origem)

(a)

r1(origem)

r2(destino)

(b)

r2(destino)

r1(origem)

(c)

r1(origem)

r2(destino)

(d)

Figura 3.2: Configuraes possveis no movimento de um bloco de memria da posioapontada por r1 para a posio apontada por r2.

r2(final do destino)

r1(final da origem)

Figura 3.3: Deslocando os apontadores para o final das posies original e destino dosblocos.


1 ; verso final2 ; move bloco de palavras3 ; entrada:4 ; r1: endereo inicial do bloco5 ; r2: endereo para onde o bloco deve ser movido6 ; r3: tamanho do bloco, em palavras de 32 bits7 MoveBloco:8 set r5,4 ; vamos usar r5 para avanar os ponteiros9 cmp r1,r2 ; inicialmente verifica qual caso10 jz inal ; origem = destino? nada a fazer11 ja vBloco ; casos (b) e (d), origem menor...12 ; que destino, move do inicio para o fim1314 ; aqui tratamos casos (a) e (c) -- embora apenas (c) cause15 ; problema mais fcil trat-los juntos; move do fim para16 ; o incio17 set r5,-4 ; o avano vai ser para trs18 mov r0,r3 ; r0 rascunho, vamos calcular o endereo19 ; da ltima palavra de cada bloco20 add r0,r0 ; r0 = 2*tamanho21 add r0,r0 ; r0 = 4*tamanho, ou seja, nmero de bytes22 sub r0,423 add r1,r0 ; r1 aponta para ltima palavra da origem24 add r2,r0 ; r2 aponta para ltima palavra da destino25 MvBloco:26 ld r0,(r1) ; copia palavra27 st (r2),r0 ; na nova posio28 add r1,r5 ; avana (ou retrocede) ponteiros29 add r2,r530 sub r3,1 ; verifica se chegou ao final do bloco31 jnz MvBloco ; no, continua movendo32 final:33 ... ; aqui quando terminou de mover o bloco

Exemplo Escreva um trecho de programa que verifique se uma cadeia de bytes pa-lndrome, ou seja, d o mesmo resultado quando lida da direita para a esquerda ou daesquerda para a direita (amor a roma um exemplo). O endereo do incio da cadeia dado em r2, e o seu comprimento (maior ou igual a 0) dado em r1. Se a cadeia palndrome, o registrador r0 deve valer zero ao final; caso contrrio, r0 deve ter o valor1 ao final.


1 ;trecho para verificar se cadeia de bytes palndrome2 ; no incio: endereo inicial da cadeia em r2 e3 ; seu comprimento em r14 ; no final: r0 igual a 0 se palndrome, 1 caso contrrio56 Palndrome:7 cmp r1,0 ; se cadeia vazia, palavra palndrome8 jz palind ; vai retornar com r0 igual a 09 mov r3,r2 ; vamos fazer ...

10 add r3,r1 ; r3 apontar ...11 sub r3,1 ; para ltimo elemento da cadeia12 proxbyte:13 ldb r0,(r2) ; elemento do incio14 ldb r1,(r3) ; elemento do final15 cmp r0,r1 ; campara os elementos16 jnz naopal ; se diferentes, palavra no palndrome17 add r2,1 ; avana ponteiro do inicio18 sub r3,1 ; retrocede ponteiro do final19 cmp r2,r3 ; verifica se cadeia terminou20 jnc palind ; sim, terminou, a palavra palndrome21 jmp proxbyte ; continua verificao22 naopal:23 set r0,124 jmp final ; termina com r0 igual a 125 palind:26 set r0,0 ; termina com r0 igual a 027 final:

Essa soluo pode ser melhorada. Primeiramente, note que existe uma sequnciade dois desvios, o primeiro condicional e o segundo incondicional, nas linhas linhas1922. Quando isto ocorre, podemos em geral rearrumar o cdigo de maneira a utilizarapenas um desvio. Uma outra modificao possvel a eliminao do teste para verificarse a cadeia vazia no incio (linhas 69), incorporando este caso no tratamento geral. Anova verso fica assim:


1 ; Palndrome - segunda verso2 ;trecho para verificar se cadeia de bytes palndrome3 ; no incio: endereo inicial da cadeia em r2 e seu4 ; comprimento em r15 ; no final: r0 igual a 0 se palndrome, 1 caso contrrio6 ; destri: r1, r2 e r37 Palndrome:8 cmp r1,0 ; se cadeia vazia, palavra palndrome9 jz palind ; vai retornar com r0 igual a 010 mov r3,r2 ; vamos fazer ...11 add r3,r1 ; r3 apontar ...12 sub r3,1 ; para ltimo elemento da cadeia13 proxbyte:14 cmp r2,r3 ; verifica se cadeia terminou15 jnc palind ; sim, terminou, a palavra palndrome16 ldb r0,(r2) ; elemento do inicio17 ldb r1,(r3) ; elemento do final18 add r2,1 ; avana ponteiro do inicio19 sub r3,1 ; retrocede ponteiro do final20 cmp r0,r1 ; campara os elementos21 jz proxbyte22 set r0,123 jmp final ; termina com r0 igual a 124 palind:25 set r0,0 ; termina com r0 igual a 026 final:

Tabelas de desvios

Uma tcnica bastante til em linguagem de montagem a utilizao de tabelas de des-vio. Para ilustrar o seu uso, vamos examinar como pode ser implementado um comandode seleo como switch em C.

Considere o seguinte trecho de programa em C:

1 switch(val) {2 case 1000:3 x= y; break;4 case 1001:5 y = x; break;6 case 1004:7 t = x;8 case 1005:9 x = 0; break;

10 default:11 x = y = t = 0;12 }


Uma maneira de implementar este trecho em linguagem de montagem compararo valor de val sequencialmente com cada um das possveis selees, como no trecho emlinguagem de montagem abaixo:

1 ; comando switch (val)2 ld r0,val ; carrega variavel de seleo3 set r1,1000 ; primeira selao4 cmp r0,r1 ; verifica se igual5 jnz sel2 ; desvia se diferente6 ; case 10007 ld r0,y8 st x,r0 ; x = y9 jmp final ; break

10 sel2:11 set r1,1001 ; segunda selao12 cmp r0,r1 ; verifica se igual13 jnz sel3 ; desvia se diferente14 ; case 100115 ld r0,x16 st y,r0 ; y = x17 jmp final ; break18 sel3:19 set r1,1004 ; terceira selao20 cmp r0,r1 ; verifica se igual21 jnz sel4 ; desvia se diferente22 ; case 100423 ld r0,x24 st t,r0 ; t = x25 jmp s1005 ; note que no h break26 sel4:27 set r1,1005 ; quarta selao28 cmp r0,r1 ; verifica se igual29 jnz sel5 ; desvia se diferente30 ; case 100531 s1005:32 set r0,033 st t,r0 ; t = 034 jmp final ; break35 ; default36 sel5:37 set r0,038 st t,r0 ; t = 039 st x,r0 ; x = 040 st y,r0 ; y = 041 final:42 ...

Esta soluo aplicvel quando o nmero N de selees pequeno. Mas note quea cada execuo do comando switch so realizadas em mdia N/2 comparaes. Se N


grande, a execuo do comando ser (em mdia) demorada. Nesse caso o mais eficiente usar uma tabela de desvios, que simplesmente uma tabela onde cada elemento umrtulo:

1 tabela_desvio:2 .dw ponto13 .dw ponto24 .dw ponto35 ...6 .dw pontoN7

Para efetuar o desvio para a posio referente ao segundo elemento da tabela, bastacarregar este elemento em um registrador e utilizar a instruo de desvio por registrador.

Um exemplo de implementao do comandoswitch acima utilizando uma tabela dedesvio :


1 ; comando switch (val)2 ld r0,val ; carrega variavel de seleo3 set r1,1000 ; primeiro verificamos os limites4 cmp r0,r1 ; menor que menor entrada na tabela?5 jc casedefault ; sim, desvia6 set r1,1005 ; compara com maior valor7 cmp r1,r08 jc casedefault ; val maior que a maior entrada na tabela9 set r1,tab_switch ; carrega endereo da tabela de desvios

10 ; r0 ser o ndice na tabela11 sub r0,1000 ; primeiro valor tem ndice zero12 add r0,r0 ; cada elemento na tabela tem 4 bytes...13 add r0,r0 ; portanto multiplicamos ndice por 414 add r0,r1 ; r0 aponta para elemento15 ld r0,(r0) ; pega elemento na tabela16 jmp r0 ; e desvia para seleo correspondente17 tab_switch:18 .dw case100019 .dw case100120 .dw casedefault21 .dw casedefault22 .dw case100423 .dw case100524 case1000:25 ld r0,y26 st x,r0 ; x = y27 jmp final ; break28 case1001:29 ld r0,x30 st y,r0 ; y = x31 jmp final ; break32 case1004:33 ld r0,x34 st t,r0 ; t = x35 ; note que no h break36 case1005:37 set r0,038 st t,r0 ; t = 039 jmp final ; break40 casedefault:41 set r0,042 st t,r0 ; t = 043 st x,r0 ; x = 044 st y,r0 ; y = 045 final:46 ...

Nesta implementao o nmero de comparaes a cada execuo do comandoswitch fixo, independente do nmero de opes existentes.

3.4. INSTRUES LGICAS 41

3.4 Instrues Lgicas

No grupo das instrues lgicas, como o nome indica, esto as instrues que efetuamoperaes lgicas como e, ou e ou-exclusivo. No Faska, as instrues lgicas operamsomente sobre registradores; ou seja, os dois operandos das instrues so registradores.Outros processadores, como os da famlia Intel x86, admitem que um dos operandosesteja na memria.

As operaes lgicas para operandos de apenas um bit so descritas na Figura 3.4.As instrues lgicas que implementam as operaes E, OU e OU-EXCLUSIVO operambit a bit, isto , bit 0 do primeiro operando com bit 0 do segundo operando, bit 1 com bit1, e assim por diante.

op1 op2 E0 0 00 1 01 0 01 1 1

op1 op2 OU0 0 00 1 11 0 11 1 1

op1 op2 OU-EXCLUSIVO0 0 00 1 11 0 11 1 0

Figura 3.4: Operaes lgicas com operandos de 1 bit

AND

E-Lgico


and rdest, rfonte rdest rdest rfonte NZ31 0

30 rdest rfonte

Exemplo


1 | .org 100h2 00000100 [30 00 02 03] | and r2,r3 ; instruo e-lgico3 | ; codificao utiliza uma4 | ; palavra


Antes

30 00 02 03 00100h

000fch

00104h88 00 e8 f2r2

Memria

f7 ea 12 66r3

00 00 01 00ip

Processador

... 0 0 flags N Z

00 00 01 04ip

Depois

30 00 02 03 00100h

000fch

00104h80 00 00 62r2

Memria

f7 ea 12 66r3

Processador

... 1 0 flagsN Z

OR

OU-Lgico


or rdest, rfonte rdest rdest rfonte NZ31 0

31 rdest rfonte

Exemplo


1 | .org 100h2 00000100 [31 00 02 03] | or r2,r3 ; instruo ou-lgico3 | ; codificao utiliza uma4 | ; palavra

Antes

31 00 02 03 00100h

000fch

00104h88 00 e8 f2r2

Memria

f7 ea 12 66r3

00 00 01 00ip

Processador

... 0 0 flags N Z

Depois

31 00 02 03 00100h

000fch

00104hff ea fa f6r2

Memria

f7 ea 12 66r3

00 00 01 04ip

Processador

... 0 1 0 0flagsC N Z V


XOR

OU-Exclusivo


xor rdest, rfonte rdest rdest rfonte NZ31 0

32 rdest rfonte

Exemplo


1 | .org 100h2 00000100 [32 00 02 03] | xor r2,r3 ; instruo ou-exclusivo3 | ; codificao utiliza uma4 | ; palavra

Antes

32 00 02 03 00100h

000fch

00104h88 00 e8 f2r2

Memria

f7 ea 12 66r3

00 00 01 00ip

Processador

... 0 0 flags N Z

Depois

32 00 02 03 00100h

000fch

00104h7f ea fa 94r2

Memria

f7 ea 12 66r3

00 00 01 04ip

Processador

... 0 0flags N Z

TEST

OU-Exclusivo


test rdest, rfonte rdest rfonte NZ31 0

33 rdest rfonte

Exemplo



1 | .org 100h2 00000100 [33 00 02 03] | test r2,r3 ; instruo test3 | ; executa operao e-lgico4 | ; mas no armazena o5 | ; resultado

Antes

33 00 02 03 00100h

000fch

00104h88 00 e8 f2r2

Memria

f7 ea 12 66r3

00 00 01 00ip

Processador

... 0 0 flags N Z

00 00 01 04ip

Depois

30 00 02 03 00100h

000fch

00104h88 00 e8 f2r2

Memria

f7 ea 12 66r3

Processador

... 1 0 flagsN Z

As instrues lgicas podem ser utilizadas por exemplo para implementar vari-veis do tipo conjunto. Por exemplo, para implementar um conjunto que tenha no m-ximo 32 elementos podemos utilizar uma palavra de memria, na qual cada bit cor-responde a um elemento do conjunto. Usando as instrues lgicas e mscaras de bitsapropriadas podemos inserir um elemento, remover um elemento ou testar a presenade um elemento no conjunto.

Exemplo


1 ; algumas mscaras de bits, uma para cada cor; em cada mscara2 ; h apenas um bit um, na posio correspondente cor3 azul .equ 01h4 verde .equ 02h5 roxo .equ 04h6 ...7 preto .equ 40000000h8 branco .equ 80000000h9 ...1011 .org 1000h12 ; reserva espao para a varivel que representa o conjunto13 cores: .ds 414 ...1516 .org 2000h17 ; insere o elemento azul no conjunto18 ld r1, cores19 set r0, azul ; mscara para elemento a inserir20 or r1, r021 st cores, r1 ; conjunto agora contm azul2223 ...2425 ; remove o elemento verde do conjunto26 ld r1, cores27 set r0, verde ; mscara para elemento a remover28 set r2, -1 ; mscara para inverter com xor29 xor r0, r2 ; mscara agora 0fffffffdh30 and r1, r0 ; zera bit correspondente a verde31 ; mantm todos os outros32 st cores, r1 ; conjunto agora no contm verde3334 ...3536 ; testa presena do elemento roxo no conjunto37 ld r1, cores38 set r0, roxo ; mscara para elemento39 test r1, r0 ; verifica bit correspondente a roxo40 jnz presente41 ; aqui quando conjunto no contm roxo42 ...43 presente:44 ; aqui quando conjunto contm roxo

No Exemplo acima a varivel carregada para um registrador a cada incio deoperao sobre o conjunto, e o registrador armazenado de volta na varivel a cada finalde operao porque so descritos apenas trechos de cdigo, e estamos assumindo queentre os trechos mostrados o registrador r1 utilizado para outros fins. Se o registradorno for utilizado para outros fins, obviamente as instrues intermedirias de carga earmazenamento podem ser eliminadas.


A instruo and pode tambm ser usada para isolar alguns bits de uma palavra dememria. Suponha que uma palavra de 32 bits est sendo usada para armazenar quatroelementos de uma estrutura, onde cada elemento um nmero de oito bits, como nadeclarao em C abaixo:

struct exemplo {char x,y,t,z;

} exemplo;z xyt

31 081624

Para isolar apenas o elemento x, podemos utilizar o seguinte trecho de cdigo:

1 ; reserva espao para a estrutura2 exemplo:3 .ds 44 ...5 ; aqui inicia o trecho para isolar o elemento x6 ld r10, exemplo ; carrega estrutura7 set r0, 0ffh ; mscara 00 00 00 ff8 and r10, r0 ; r10 tem o elemento x isolado

Para isolar y, o segundo elemento da estrutura, podemos nos valer da mesma ideia,e utilizar uma mscara com valor 0ff00h:

1 ; aqui inicia o trecho para isolar o elemento y2 ld r9, exemplo ; carrega estrutura3 set r0, 0ff00h ; mscara 00 00 ff 004 and r9, r0 ; r9 tem o elemento y isolado

No entanto, apesar de o elemento y estar isolado ao final do trecho, ele no estposicionado no byte menos significativo de r9. Assim, fica impossvel por exemplocomparar se x e y tm o mesmo valor. Para tanto, seria necessrio deslocar o valor der9 de oito bits para a direita.

Os processadores incluem no repertrio instrues que permitem diferentes formasde efetuar deslocamentos deste tipo: para a direita, para a esquerda, e ainda outrasformas. Estas instrues so apresentadas na seo a seguir.

3.5. INSTRUES DE DESLOCAMENTO 47

3.5 Instrues de deslocamento

As instrues de deslocamento do Faska operam sempre sobre um registrador, e deslo-cam os bits do registrador operando para a direita ou para a esquerda. Todos os bits sodeslocados ao mesmo tempo. Por exemplo, no deslocamento simples para a esquerda, obit b0 (menos significativo) do registrador deslocado para a posio do bit b1, que porsua vez deslocado para a posio do bit b2, e assim por diante. A Figura 3.5 ilustra asoperaes de deslocamento para a esquerda e para a direita.

x b31 b1b2b3b30 ...

(b)

b31 b30 b0b1b2b29 ...

Antes

Depois

sentido do deslocamento

b0

x

b29 xb0b1b28 ...

(a)

b31 b30 b0b1b2b29 ...

Antes

Depois

sentido do deslocamento

b31

x

b30

Figura 3.5: Operaes de deslocamento (a) para a esquerda e (b) para a direita

As variaes existentes das instrues de deslocamento derivam das diferentespossibilidades sobre o que acontece com o bit que sai do registrador (b0 no desloca-mento para a direita e b31 no deslocamento para a esquerda) e sobre o bit que entrano registrador (representado por x na Figura 3.5, que entra no lugar de b31 no desloca-mento para a direita e no lugar de b0 no deslocamento para a esquerda).

Em todas as instrues de deslocamento o nmero de bits que o registrador deveser deslocado dado no segundo operando, que pode ser uma constante codificada comendereamento imediato, ou pode ser um outro registrador. Quando a instruo indicaque o registrador deve ser deslocado de mais do que um bit (ou seja, o valor do segundooperando maior do que um) a operao de deslocamento ilustrada na Figura 3.5 repetida o nmero de vezes indicado pelo valor do segundo operando.

3.5.1 Deslocamento simples

Nas instrues de deslocamento simples o bit que ejetado do registrador copiadono bit de estado C. Se a instruo de deslocamento indica que o registrador deve serdeslocado de mais de um bit, o valor copiado no bit de estado o ltimo a ser ejetadodo registrador. O valor do bit que injetado a cada deslocamento sempre igual a zero.


Deslocamento para a direita

SHR

Deslocamento para a direita


shr rdest, expr5

repita imd5 vezes {rdest[i] rdest[i+ i]C rdest[0]rdest[31] 0

}

CNZ31 0

40 imd8 rdest

shr rdest, rfonte

repita rfonte vezes {rdest[i] rdest[i+ i]C rdest[0]rdest[31] 0

}

CNZ31 0

41 rdest rfonte

Exemplo


1 |; exemplos de instrues de deslocamento2 |3 | .org 200h4 00000200 [40 01 0a 00] | shr r10,1 ; deslocamento para a5 | ; direita, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [41 00 0b 03] | shr r11,r3 ; deslocamento para a9 | ; direita, por registrador

10 | ; codificao utiliza uma11 | ; palavra

Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

40 01 0a 00

41 00 0b 03

Processador

00208h

... 0 0 0 flagsC S Z Depois

00 00 00 07r3Memria

2a aa aa aar10

01 fe 00 00r11

00 00 02 08ip

00200h

00204h

40 01 0a 00

41 00 0b 03

Processador

00208h

... 0 0 0 flagsC S Z


Deslocamento para a esquerda

SHL

Deslocamento para a esquerda


shl rdest, expr5

repita imd5 vezes {rdest[i+ 1] rdest[i]C rdest[31]rdest[0] 0

}

CNZ31 0

42 imd8 rdest

shl rdest, rfonte

repita rfonte vezes {rdest[i+ 1] rdest[i]C rdest[31]rdest[0] 0

}

CNZ31 0

43 rdest rfonte

Exemplo


1 | ; exemplos de instrues de deslocamento2 |3 | .org 200h4 00000200 [42 01 0a 00] | shl r10,1 ; deslocamento para a5 | ; esquerda, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [43 00 0b 03] | shl r11,r3 ; deslocamento para a9 | ; esquerda, por registrador

10 | ; codificao utiliza uma11 | ; palavra

Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

42 01 0a 00

43 00 0b 03

Processador

00208h

... 0 0 0 flagsC N Z Depois

00 00 00 07r3Memria

aa aa aa aar10

80 00 00 00r11

00 00 02 08ip

00200h

00204h

42 01 0a 00

43 00 0b 03

Processador

00208h

... 1 1 0 flagsC N Z


Operaes de deslocamento so muito teis para efetuar a diviso ou multiplicaode um nmero inteiro por uma potncia de 2. Como visto no Captulo ??, cada deslo-camento de um bit para a direita divide o operando por dois, e cada deslocamento deum bit para a esquerda multiplica o operando por 2, se o operando um nmero inteiropositivo.

Deslocamento aritmtico para a direita

Se o operando um nmero inteiro negativo, a instruo de deslocamento simples para adireita no pode ser usada para divid-lo por 2, pois como zeros so injetados o resultadoser sempre positivo. Por esta razo uma outra instruo de deslocamento fornecidapelo Faska, o deslocamento aritmtico para a direita.

A diferena entre o deslocamento simples e o aritmtico que no aritmtico aoinvs de serem injetados zeros, o bit mais significativo do operando usado na injeo.Ou seja, o bit de sinal do operando repetido e deslocado para a direita. Assim, quandoo operando representar um nmero inteiro com sinal em complemento de dois, se ovalor inicial negativo, o resultado tambm o ser (e valer metade do valor inicial).Observe que a instruo simtrica sal no necessria.

SAR



sar rdest, expr5

repita imd5 vezes {rdest[i] rdest[i+ i]C rdest[0]rdest[31] 0

}

CNZ31 0

44 imd5 rdest

sar rdest, rfonte

repita rfonte vezes {rdest[i] rdest[i+ i]C rdest[0]rdest[31] rdest[31]

}

CNZ31 0

45 rdest rfonte

Exemplo



1 | ; exemplos de instrues de deslocamento2 |3 | .org 200h4 00000200 [44 01 0a 00] | sar r10,1 ; deslocamento aritmtico5 | ; para a direita, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [45 00 0b 03] | sar r11,r3 ; deslocamento aritmtico9 | ; para a direita, por

10 | ; registrador11 | ; codificao utiliza uma12 | ; palavra

Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

44 01 0a 00

45 00 0b 03

Processador

00208h


00 00 00 07r3Memria

2a aa aa aar10

ff fe 00 00r11

00 00 02 08ip

00200h

00204h

44 01 0a 00

45 00 0b 03

Processador

00208h


3.5.2 Deslocamentos com rotao

No deslocamento com rotao, o bit ejetado do registrador injetado novamente, ou di-retamente no registrador, no lado oposto de onde o bit foi ejetado (no caso das instruesde rotao para a direita e para a esquerda), ou no bit de estado vai-um (bit C), no casodas instrues de rotao com vai-um para a esquerda e para a direita.


Rotao para a direita

ROR



ror rdest, expr5

repita imd5 vezes {rdest[i] rdest[i+ 1]C rdest[0]rdest[31] rdest[0]

}

CNZ31 0

48 imd5 rdest

ror rdest, rfonte

repita rfonte vezes {rdest[i] rdest[i+ 1]C rdest[0]rdest[31] rdest[0]

}

CNZ31 0

49 rdest rfonte

Exemplo


1 | ; exemplos de instrues de rotao2 |3 | .org 200h4 00000200 [48 01 0a 00] | ror r10,1 ; rotao para a5 | ; direita, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [49 00 0b 03] | ror r11,r3 ; rotao para a9 | ; direita, por registrador

10 | ; codificao utiliza uma11 | ; palavra12


Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

48 01 0a 00

49 00 0b 03

Processador

00208h


00 00 00 07r3Memria

55 55 55 55r10

1f e0 00 00r11

00 00 02 08ip

00200h

00204h

48 01 0a 00

49 00 0b 03

Processador

00208h


Rotao para a esquerda

ROL



rol rdest, expr5

repita imd5 vezes {rdest[i+ 1] rdest[i]C rdest[31]rdest[0] rdest[31]

}

CNZ31 0

46 imd5 rdest

rol rdest, rfonte

repita rfonte vezes {rdest[i+ 1] rdest[i]C rdest[31]rdest[0] rdest[31]

}

CNZ31 0

47 rdest rfonte

Exemplo



1 |; exemplos de instrues de rotao2 |3 | .org 200h4 00000200 [46 01 0a 00] | rol r10,1 ; rotao para a5 | ; esquerda, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [47 00 0b 03] | rol r11,r3 ; rotao para a9 | ; esquerda, por registrador


Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

46 01 0a 00

47 00 0b 03

Processador

00208h


00 00 00 07r3Memria

55 55 55 55r10

80 00 00 3fr11

00 00 02 08ip

00200h

00204h

46 01 0a 00

47 00 0b 03

Processador

00208h


Rotao com vai-um para a direita

RCR



rcr rdest, expr5

repita imd5 vezes {rdest[i] rdest[i+ 1]rdest[31] CC rdest[0]

}

CNZ31 0

48 imd5 rdest

rcr rdest, rfonte

repita rfonte vezes {rdest[i] rdest[i+ 1]rdest[31] CC rdest[0]

}

CNZ31 0

49 rdest rfonte


Exemplo


1 |; exemplos de instrues de rotao2 |3 | .org 200h4 00000200 [4c 01 0a 00] | rcr r10,1 ; rotao com vai-um para a5 | ; direita, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [4d 00 0b 03] | rcr r11,r3 ; rotao com vai-um para a9 | ; direita, por registrador


Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

4c 01 0a 00

4d 00 0b 03

Processador

00208h


00 00 00 07r3Memria

aa aa aa aar10

3f e0 00 00r11

00 00 02 08ip

00200h

00204h

4c 01 0a 00

4d 00 0b 03

Processador

00208h



Rotao com vai-um para a esquerda

RCL



rcl rdest, expr5

repita imd5 vezes {rdest[i+ 1] rdest[i]rdest[0] CC rdest[31]

}

CNZ31 0

4b imd5 rdest

rcl rdest, rfonte

repita rfonte vezes {rdest[i+ 1] rdest[i]C rdest[31]rdest[0] rdest[31]

}

CNZ31 0

4c rdest rfonte

Exemplo


1 |; exemplos de instrues de rotao2 |3 | .org 200h4 00000200 [4a 01 0a 00] | rcl r10,1 ; rotao com vai-um para a5 | ; esquerda, imediato6 | ; codificao utiliza uma7 | ; palavra8 00000204 [4b 00 0b 03] | rcl r11,r3 ; rotao com vai-um para a9 | ; esquerda, por registrador



Antes

00 00 00 07r3Memria

55 55 55 55r10

ff 00 00 00r11

00 00 02 00ip

00200h

00204h

4a 01 0a 00

4b 00 0b 03

Processador

00208h


00 00 00 07r3Memria

aa aa aa abr10

80 00 00 ffr11

00 00 02 08ip

00200h

00204h

4a 01 0a 00

4b 00 0b 03

Processador

00208h


A Figura 3.5.2 mostra um resumo das operaes de deslocamento de forma esque-mtica.

031Creg

shldeslocamento para a esquerda

031Creg

shrdeslocamento para a direita

0 0

031Creg

sardeslocamento aritmtico para a direita

031Creg

rolrotao para a esquerda

031Creg

rorrotao para a direita

031Creg

rclrotao com vai-umpara a esquerda

rcrrotao com vai-um para a direita

031Creg

Figura 3.6: Resumo das instrues de deslocamento e rotao

Exemplo Vamos escrever um trecho de programa que troque os bits mais e menos sig-nificativos de r0, sem alterar os bits restantes, como ilustrado na Figura 3.7.


xy31

Antes

0yx

31

Depois

0

Figura 3.7: Invertendo o bit mais significativo com o menos significativo.

1 ; trecho para inverter o bit mais significativo com o menos2 ; significativo de r03 ; r0 tem ybb..bbx4 xor r1,r1 ; zera r1, vamos montar x00..00y em r15 shr r0,1 ; C = x, r0 tem 0ybb..bb6 rcr r1,2 ; r1 tem 0x00..007 shl r0,2 ; C = y, r0 tem bb..bb008 rcl r1,1 ; r1 tem x00...00y9 shr r0,1 ; r0 tem 0bb...bb0

10 or r0,r1 ; e bits so invertidos!

Exemplo Suponha que r12 contm o endereo inicial de uma cadeia de oito caracteres0 ou 1 que representa um nmero em notao binria, sendo que r12 aponta para ocaractere que representa o bit mais significativo da cadeia. Vamos escrever um trechode programa que coloque em r0 o valor que a cadeia dada representa. Por exemplo, sea cadeia de caracteres 01011011 (em hexadecimal, os valores dos caracteres so 30h,31h, 30h, 31h, 31h, 30h, 31h, 31h), o valor de r0 ao final do trecho deve ser 5bh.

1 ; trecho para calcular valor binrio representado por uma2 ; cadeia de caracteres 0 e 1 apontada por r123 ; primeira verso45 set r1, 8 ; vamos usar como contador6 xor r0, r0 ; r0 ser usado como temporrio7 set r11, 1 ; auxiliar, mascara para bit 08 ; vamos montar valor bit a bit9 prox_dig:

10 ldb r2, (r12) ; r2 tem dgito: 30h ou 31h11 shl r0, 1 ; prepara espao para novo bit12 sub r2, 30h ; r2 tem o valor do dgito: 0 ou 113 or r0, r11 ; monta novo bit com valor 114 add r12, 1 ; avana apontador15 sub r1, 1 ; chegou ao final da cadeia?16 jnz prox_dig ; no, trata mais dgitos17 ... ; sim, trmino; valor do byte em r0

Podemos melhorar esta soluo notando que o resultado da instruo sub na li-nha 12 sempre zero ou um; dessa forma, podemos eliminar a necessidade do desviocondicional da linha 13:


1 ; trecho para calcular valor binrio representado por uma2 ; cadeia de caracteres 0 e 1 apontada por r123 ; segunda verso45 set r1, 8 ; vamos usar como contador6 xor r0, r0 ; r0 ser usado como temporrio7 ; vamos montar valor bit a bit8 prox_dig:9 ldb r2, (r12) ; r2 tem dgito: 30h ou 31h10 shl r0, 1 ; prepara espao para novo bit11 sub r2, 30h ; r2 tem o valor do dgito: 0 ou 112 or r0, r2 ; monta novo bit com valor 0 ou 113 add r12, 1 ; avana apontador14 sub r1, 1 ; chegou ao final da cadeia?15 jnz prox_dig ; no, trata mais dgitos16 ... ; sim, trmino; valor do byte em r0

Ainda uma outra verso, desta vez usando operaes de rotao com o bit de es-tado C para diminuir ainda mais o nmero de instrues do loop nas linhas 815:

1 ; trecho para calcular valor binrio representado por uma2 ; cadeia de caracteres 0 e 1 apontada por r123 ; terceira verso45 set r1, 8 ; vamos usar r1 como contador6 xor r0, r0 ; r0 ser usado como temporrio7 ; vamos montar valor bit a bit8 prox_dig:9 ldb r2, (r12) ; r2 tem dgito: 30h ou 31h, coloca10 rcr r2, r1 ; novo bit 0 ou 1 no bit vai-um11 rcl r0, 1 ; monta novo bit12 add r12, 1 ; avana apontador13 sub r1, 1 ; chegou ao final da cadeia?14 jnz prox_dig ; no, trata mais dgitos15 ... ; sim, trmino; valor do byte em r0

Documents

cap3 processador Faíska