Assembly Saltos e Subrotinas

(1)

Aula 6

Assembly

Saltos e Subrotinas

6.1 Objectivos . . . 1

6.2 Introdu¸c˜ao . . . 1

6.3 Ciclos e outras estruturas de controlo . . . 2

6.3.1 Ciclos . . . 2

6.3.2 Estruturas if then else . . . 4

6.3.3 Escolha m´ultipla . . . 5

6.4 Subrotinas . . . 5

6.5 Escolha autom´atica de instru¸c˜oes . . . 6

6.6 Utiliza¸c˜ao de segmentos recoloc´aveis . . . 7

6.7 Problemas . . . 8

6.1 Objectivos

Consolida¸cão de conhecimentos sobre a linguagem assembly da fam´ılia 51. Fa-miliariza¸cão com as instru¸cões de salto e chamada de subrotinas. Utiliza¸cão da pilha (stack) e respectivo apontador (stack pointer).

6.2 Introdu¸

c˜

ao

Conclui-se com este guião uma breve introdu¸cão à linguagem assembly da fa-m´ılia 51. Apresentam-se aqui diversos problemas que obrigam à utiliza¸cão de instru¸cões de salto e à organiza¸cão do código em subrotinas. Estude com cui-dado os exemplos apresentados e as considera¸cões que os acompanham e depois tente resolver em casa, antes da aula, todos os problemas propostos. Poderá tirar as dúvidas que lhe surgirem na aula teórico-prática.

(2)

6.3 Ciclos e outras estruturas de controlo

A linguagem assembly não dispõe de nenhum mecanismo que leve a programar de modo estruturado. Assim, a estrutura de um programa é mais uma das res-ponsabilidades que o programador deve assumir. Felizmente é fácil implementar algumas estruturas de controlo existentes em linguagens de alto n´ıvel recorrendo a instru¸cões de salto.

6.3.1 Ciclos

A maneira mais fácil de controlar a execu¸cão de determinado grupo de instru¸cões um número constante de vezes é utilizando a instru¸cão DJNZ (decrement and jump if not zero) que admite como operando um registo ou um endere¸co de memória de dados interna:

LOC OBJ LINE SOURCE

1 ;============================================== 2 ; Inicializa¸c~ao de um vector em mem´oria 3 ; for(i=0;i<16;i++) { 4 ; temp[i]=0 5 ; } 6 ; [email protected] 7 ;============================================== 8

0010 9 SIZE equ 16 ; Tamanho do vector 10

---- 11 dseg at 40h 0040 12 temp: ds SIZE

13

---- 14 cseg at 0

0000 7840 15 mov r0,#temp ; Endere¸co inicial 0002 E4 16 clr a

0003 7F10 17 mov r7,#SIZE ; Tamanho

0005 F6 18 next: mov @r0,a ; Inicializa posi¸c~ao 0006 08 19 inc r0

0007 DFFC 20 djnz r7,next 21

22 end

Repare-se, a propósito deste exemplo, na utiliza¸cão da constante numérica SIZE definida na linha 9 e utilizada nas linhas 12 e 17. É também importante perceber o modo como se pode aceder de forma indirecta a uma variável: o apontador é inicializado (linha 15) e mais tarde (linha 18) utilizado para aceder às sucessivas posi¸cões que a variável ocupa.

Um ciclo pode tamb´em ser do tipo enquanto ou do tipo repetir. O primeiro caracteriza-se por ter o teste de controlo logo no in´ıcio o que faz com que o conjunto de instru¸c˜oes nele inclu´ıdo possa nunca ser executado; o segundo caracteriza-se por ter o teste de controlo no fim pelo que o conjunto de instru-¸

c˜oes nele inclu´ıdo ´e executado pelo menos uma vez:

LOC OBJ LINE SOURCE

(3)

6.3. CICLOS E OUTRAS ESTRUTURAS DE CONTROLO 3 3 ; unsigned char x; 4 ; unsigned int y; 5 ; 6 ; while (x!=0) { 7 ; y=2*y; 8 ; x--; 9 ; } 10 ; [email protected] 11 ;======================================= 12 ---- 13 dseg at 40h 0040 14 y: ds 2 0042 15 x: ds 1 16 ---- 17 cseg at 0

0000 E542 18 tst: mov a,x ; Testa em A 0002 600F 19 jz done ; Acaba se A=0

20

21 ; Multiplica por 2 um n´umero de 16 bits 0004 C3 22 clr c

0005 E541 23 mov a,y+1 ; Processa LSB 0007 33 24 rlc a

0008 F541 25 mov y+1,a

000A E540 26 mov a,y ; Processa MSB 000C 33 27 rlc a 000D F540 28 mov y,a 29 000F 1542 30 dec x 0011 80ED 31 sjmp tst 32 0013 33 done: 34 35 36 37 ;======================================= 38 ; Ciclo do tipo repetir...

39 ; unsigned char x; 40 ; unsigned int y; 41 ; 42 ; do { 43 ; y=2*y; 44 ; x--; 45 ; } while (x!=0); 46 ; [email protected] 47 ;======================================= 48 ---- 49 cseg at 0100h 50

0100 E541 51 next: mov a,y+1 ; Processa LSB 0102 25E0 52 add a,acc

0104 F541 53 mov y+1,a

0106 E540 54 mov a,y ; Processa MSB 0108 33 55 rlc a 0109 F540 56 mov y,a 57 010B D542F2 58 djnz x,next 59 60 end

(4)

6.3.2 Estruturas if then else

As instru¸cões de salto permitem uma implementa¸cão confortável deste tipo de estruturas de controlo nos programas escritos em assembly:

LOC OBJ LINE SOURCE

1 ;======================================= 2 ; Teste de valores

3 ; #define MAXCNT 15000 4 ; unsigned int cont,val; 5 ; unsigned char state; 6 ; if(val==0) { 7 ; state++; 8 ; cont=MAXCNT; 9 ; } else { 10 ; if(state==12) 11 ; state--; 12 ; } [email protected] 13 ;======================================= 14

3A98 15 MAXCNT equ 15000 16 ---- 17 dseg at 50h 0050 18 cont: ds 2 0052 19 val: ds 2 0054 20 state: ds 1 21 ---- 22 cseg at 0h 0000 E552 23 mov a,val 0002 4553 24 orl a,val+1 0004 700A 25 jnz nzero 0006 0554 26 inc state

0008 755098 27 mov cont,#low(MAXCNT) ; LSB 000B 75513A 28 mov cont+1,#high(MAXCNT) ; MSB 000E 8007 29 sjmp done

0010 740C 30 nzero: mov a,#12 0012 B55402 31 cjne a,state,done 0015 1554 32 dec state 0017 33 done:

34

Algumas considera¸c˜oes sobre o exemplo apresentado:

1. Uma vez que a vari´avel val (linha 18) ocupa 2 bytes o teste efectuado (linhas 22, 23 e 24) deve incluir ambos.

2. Nas linhas 26 e 27 foram utilizados dois operadores suportados pelo as-semblador (low e high) que calculam, respectivamente, a metade menos significativa e mais significativa de um valor de 16 bits.

(5)

6.4. SUBROTINAS 5

6.3.3 Escolha m´

ultipla

A instru¸cão de compara¸cão CJNE permite também implementar estruturas de escolha múltipla semelhantes às que existem em linguagens de alto n´ıvel:

LOC OBJ LINE SOURCE

1 ;======================================= 2 ; Escolha m´ultipla

3 ; unsigned char op,pin; 4 ; switch (op) { 5 ; case 0: pin=100;break; 6 ; case 9: pin=200;break; 7 ; default: pin=0; 8 ; } 9 ; [email protected] 10 ;======================================= 11 ---- 12 dseg at 50h 0050 13 op: ds 1 0051 14 pin: ds 1 15 ---- 16 cseg at 100h 0100 E550 17 mov a,op

0102 B40004 18 cjne a,#0,Not0 ; A = 0 ? 0105 7464 19 mov a,#100

0107 8008 20 sjmp Done

0109 B40904 21 Not0: cjne a,#9,Not9 ; A = 9 ? 010C 74C8 22 mov a,#200

010E 8001 23 sjmp Done

0110 E4 24 Not9: clr a ; default... 0111 F551 25 Done: mov pin,a

26

27 end

1. A compara¸cão (linhas 18 e 21) não estraga o acumulador pelo que basta carregá-lo uma vez (linha 17).

2. Novamente se nota nos códigos da instru¸cão de compara¸cão e salto (linhas 18 e 21) a distância entre o endere¸co da próxima instru¸cão e o endere¸co destino do salto, 4 bytes nos dois casos deste exemplo.

3. A instru¸c˜ao MOV (linha 25) completa a execu¸c˜ao. E sempre executada´ qualquer que seja a escolha feita.

6.4 Subrotinas

As instru¸c˜oes de chamada de subrotinas1 _{contribuem decisivamente para a}

es-trutura dos programas ao permitirem dividir uma tarefa complexa em tarefas mais simples, cada uma executada por uma rotina que em devido tempo ser´a chamada.

1 _{Os termos rotina e subrotina ser˜}_{ao usados indistintamente para especificar um conjunto}

(6)

LOC OBJ LINE SOURCE

1 ;======================================= 2 ; Atraso configur´avel

3 ; 4 ; delay(n) { 5 ; for(i=n;i>0;i--); 6 ; } 7 ; delay(50); 8 ; delay(100); 9 ; [email protected] 10 ;======================================= 11 ---- 12 cseg at 0 0000 7F32 13 mov r7,#50 0002 120680 14 lcall delay 0005 7F64 15 mov r7,#100 0007 D180 16 acall delay 0009 80FE 17 stop: sjmp stop

18

---- 19 cseg at 0680h

0680 00 20 delay: nop ; Par^ametro de entrada em r7 0681 00 21 nop

0682 DFFC 22 djnz r7,delay ; Repete R7 vezes 0684 22 23 ret

24

25 end

1. A codifica¸cão manual da instru¸cão LCALL (linha 14) é bastante mais sim-ples e directa do que a da instru¸cão ACALL (linha 16). Naquela aparece de forma evidente o endere¸co destino enquanto nesta parte do endere¸co é incorporada no código da instru¸cão [1, páginas 17 e 36].

2. A instru¸cão de salto é necessária para encravar o programa, caso contr´ a-rio depois de executada a instru¸cão da linha 16 o programa executaria novamente a subrotina e corromperia a stack ao executar um RET sem ter executado primeiro o ACALL ou LCALL correspondente.

6.5 Escolha autom´

atica de instru¸

c˜

oes

A escolha de uma entre as três instru¸cões de salto incondicional que esta fam´ılia suporta (ljmp, ajmp e sjmp) faz-se em fun¸cão do tamanho do salto que se pretende dar. A maior parte dos assembladores actualmente existentes permite fazer essa escolha de uma forma automática: basta indicar como instru¸cão a mnemónica genérica jmp que o próprio assemblador escolherá a instru¸cão mais indicada das três.

(7)

6.6. UTILIZA ¸C ˜AO DE SEGMENTOS RECOLOC ´AVEIS 7

6.6 Utiliza¸

c˜

ao de segmentos recoloc´

aveis

A utiliza¸cão de segmentos absolutos, já abordada anteriormente [3], tem a grande desvantagem obrigar a um grande cuidado na sua utiliza¸cão para ga-rantir a inexistência de sobreposi¸cões entre segmentos do mesmo tipo. Para evitar esse trabalho e facilitar a reutiliza¸cão de código é recomendável trabalhar sempre com segmentos recolocáveis.

Ao contrário de um segmento absoluto, um segmento recolocável é aquele do qual não se sabe, a priori, o endere¸co inicial pois ele é definido pelo linker, isto é, depois da compila¸cão. A figura 6.1 ilustra as fases necessárias à cria¸cão de um ficheiro executável. Os segmentos recolocáveis definidos no código fonte ainda não estão definidos nos ficheiros objecto, estando por isso incompleta a codifica¸cão das instru¸cões. O processo de codifica¸cão é completado pelo linker antes da gera¸cão do ficheiro executável.

Assemblador / Compilador - -Assemblador / Compilador - -Assemblador / Compilador - -Li n k er -

-Ficheiros fonte Ficheiros objecto

Ficheiro execut´avel

6 6

Figura 6.1: Processo de gera¸c˜ao de um ficheiro execut´avel

A defini¸cão de um segmento recolocável faz-se com o comando segment e a sua activa¸cão com o comando rseg. O exemplo ilustra a sintaxe:

rotinas segment code ; Segmento recolocável em MP mensagens segment code ; Segmento recolocável em MP vars segment data ; Segmento recolocável em MDI vars2 segment xdata ; Segmento recolocável em MDE rseg vars ; Activa o segmento de dados

total: DS 2 ; Reserva dois bytes em MDI

contador: DS 1 ; Reserva um byte em MDI

rseg vars2 ; Activa o segmento de dados

dados: DS 400 ; Reserva 400 bytes em MDE

; === Programa principal =============================================== cseg at 0000h ; Segmento absoluto em MP

. ; In´ıcio do programa sempre no endere¸co 0 .

.

; --- Rotinas de E/S ---rseg rotinas ; Activa o segmento rotinas

. . .

; === Mensagens do sistema ============================================= rseg mensagens ; Activa o segmento mensagens

(8)

No exemplo apresentado, a ´unica conclus˜ao que se pode tirar quanto a endere¸cos ´

e que o programa principal come¸ca no endere¸co 0000h da memória de progra-mas pois é o único segmento absoluto existente. Os endere¸cos dos segmentos recolocáveis são definidos mais tarde, automaticamente, durante o processo de gera¸cão do código máquina.

6.7 Problemas

Apresentam-se de seguida alguns problemas que requerem a utiliza¸c˜ao de ins-tru¸c˜oes de salto e/ou de chamada de subrotinas.

1. Escreva um programa que calcule t =

19

X

i=0

y[i] supondo que:

(a) os elementos do vector s˜ao todos inferiores a 13, (b) os elementos do vector s˜ao todos inferiores a 256.

Declare as vari´aveis num segmento de dados absoluto com in´ıcio em 30h.

2. Escreva um programa que implemente na vari´avel Cont – definida num segmento de dados recoloc´avel – um contador c´ıclico de 24 bits. Considere dois casos:

(a) contagem crescente: 0, 1, 2, . . . , 224− 1, 0, 1, . . . , (b) contagem decrescente.

3. Suponha um vector v com 50 elementos de um byte cada representados em complemento para 2. Escreva um programa que conte quantos elementos negativos, nulos e positivos existem no vector. As contagens devem ser guardadas nas variáveis nn, nz e np respectivamente. Declare todas as variáveis num segmento recolocável em MDI. Repita considerando agora que v está declarado num segmento recolocável em MDE.

4. Traduza para código máquina as solu¸cões do problema anterior.

5. Escreva um programa que calcule a soma de controlo simples (soma efec-tuada sem considerar eventuais transportes) de uma zona de 256 bytes de mem´oria com in´ıcio apontado pelo registo R0. No fim: R0 fica a apontar para um endere¸co 256 posi¸c˜oes acima do seu valor inicial e o resultado da soma deve ficar no acumulador.

6. Escreva uma rotina que calcule o valor m´ınimo de uma zona de mem´oria de dados externa com in´ıcio apontado pelo registo DPTR e comprimento indicado no registo R7. No fim, o m´ınimo deve ficar em R7.

(9)

6.7. PROBLEMAS 9

(a) Escreva um programa que, recorrendo a essa rotina, converta para mai´usculas um texto em MDI com in´ıcio apontado por R0 e cujo fim ´

e indicado pelo c´odigo 0. (b) Escreva a rotina Upcase.

8. Suponha já existente a rotina CountBits que conta o número de bits a um do acumulador, devolvendo o resultado também no acumulador.

(a) Escreva um programa que, recorrendo a essa rotina, conte o n´umero de bits a um de uma zona de mem´oria da dados interna com in´ıcio apontado pelo registo R0 e comprimento indicado no registo R7. O resultado deve ficar em R7.

(10)

(11)

Referˆ

encias

[1] Philips semiconductors; 80C51 family programmer’s guide and instruction set ; Setembro de 1997.

[2] Ferreira, Jos´e Manuel; Resumo das instru¸c˜oes do 80C51 ; FEUP, Setembro de 2000.

[3] Sousa, Jo˜ao Paulo; Assembly: Primeiros passos; FEUP, Setembro de 2003.

[4] Atmel Wireless and Microcontrollers; 89C51 data sheet ; Setembro de 1999.

[5] Ferreira, José Manuel; Introdu¸cão ao Projecto com Sistemas Digitais e Mi-crocontroladores; FEUP Edi¸cões, 1998, ISBM 972-752-032-4.