Programação em Linguagem Assembly (Saltos e Subrotinas)

Transcrição

1 Programação em Linguagem Assembly (Saltos e Subrotinas) João Paulo Sousa jpsousa@fe.up.pt Setembro 2005 Conteúdo 1 Objectivos 2 2 Introdução 2 3 Ciclos e estruturas de controlo Ciclos for() Ciclos enquanto() Ciclos repetir() Estruturas if then else Estruturas de escolha múltipla Chamada e retorno de subrotinas 6 5 Problemas 7 1

2 1 Objectivos Consolidação de conhecimentos sobre programação em linguagem assembly da família 51. Familiarização com as instruções de salto e chamada de subrotinas. Utilização da stack e do stack pointer. 2 Introdução Ao contrário do que se passa nas linguagens de alto nível, a linguagem assembly não dispõe mecanismos próprios que conduzam a programar de modo estruturado. Felizmente é fácil implementar algumas estruturas de controlo existentes em linguagens de alto nível recorrendo a instruções de salto. Estude com cuidado os exemplos apresentados e as considerações que os acompanham bem como um dos livros recomendados [2, secção 2.4] e depois resolva os problemas propostos. 3 Ciclos e estruturas de controlo 3.1 Ciclos for() A maneira mais fácil de controlar a execução de determinado grupo de instruções um número de vezes conhecido é utilizar a instrução DJNZ (decrement and jump if not zero) que admite como operando um registo (djnz Rn,rel8) ou uma variável definida em memória (djnz direct,rel8). Repare-se no seguinte exemplo: 2 ; Inicializaç~ao de variáveis em memória 4 ; for(i=0;i<20;i++) { 5 ; temp[i]=0 6 ; } 7 ; tmed=0; 8 ;==================================================================== SIZE equ 20 ; Tamanho do vector dseg at 40h ; Segmento (absoluto) de dados temp: ds SIZE ; Vector temperaturas tmed: ds 1 ; Temperatura média cseg at 0000h ; Segmento (absoluto) de código mov r0,#temp ; Endereço inicial do vector 0002 E4 18 clr a F10 19 mov r7,#size ; Tamanho do vector 0005 F6 20 next: ; Inicializa (limpa) posiç~ao apontada inc r0 ; Aponta posiç~ao seguinte 0007 DFFC 22 djnz r7,next ; Salta se R7 for diferente de zero 0009 F6 23 ; Inicializa (limpa) tmed end 1. O segmento de dados começa no endereço 40h (linha 12) e a variável temp ocupa 20 (14h) bytes (linhas 13 e 10), logo é lógico que o endereço da variável tmed (linha 14) seja 54h. 2. O registo R0 funciona como apontador para o vector temp e deve ser inicialmente carregado com o endereço da primeira posição do vector (linha 17). 3. O inicio do ciclo de limpeza do vector temp é assinalado com a etiqueta next (linha 20). Fora do ciclo (linha 19) o registo R7, que funciona como contador, é inicializado com o número de posições do vector. 2

3 4. A instrução djnz, de decremento, comparação e salto, é codificada em dois bytes: no primeiro está o código da instrução e no segundo a distância entre o endereço da próxima instrução e o endereço destino, neste caso, quatro bytes para trás. Esta distância, que pode tomar valores de 128 a +127, é expressa num byte em complemento para dois, o que justifica a representação FCh (= 4) que se pode constatar na listagem. 5. No fim do ciclo o apontador aponta uma posição além da última do vector temp, ou seja, aponta justamente para a variável tmed pelo que (linha 23) basta escrever lá o valor zero. 3.2 Ciclos enquanto() Um ciclo deste tipo caracteriza-se por ter o teste de controlo logo no início pelo que o conjunto de instruções que encerra pode nunca ser executado. O exemplo seguinte introduz a instrução de salto condicional jz (jump if accumulator is zero) e o salto incondicional jmp: 2 ; Ciclo enquanto 4 ; while(cont!=0) { 5 ; cont-- 6 ; } 7 ; cont=100; 8 ;==================================================================== dseg at 40h ; Segmento (absoluto) de dados cont: ds 1 ; Contador cseg at 0000h ; Segmento (absoluto) de código E next: mov a,cont ; Teste da jz done ; condiç~ao de fecho do ciclo dec cont F8 18 jmp next ; Volta ao início do ciclo done: mov cont,#100 ; Atribuiç~ao final end 1. O teste de controlo do ciclo é feito no início de cada iteração (linhas 15 e 16) de modo que se inicialmente a variável cont for nula, o ciclo não se realiza nenhuma vez. 2. O salto na linha 18 é essencial para garantir a repetição do teste no início de cada iteração. A propósito deste salto convém esclarecer que jmp não é uma instrução no sentido estrito da palavra, mas sim uma instrução virtual, própria do assemblador da Keil, que este transforma automaticamente numa de três instruções reais: sjmp (short jump), ajmp (absolute jump) ou ljmp (long jump) consoante a distância ao destino especificada no salto em questão. Aqui, a codificação resultante (80h, linha 18) corresponde, como seria de esperar atendendo à distância, à da instrução sjmp. 3. Mais uma vez a codificação das instruções de salto utilizadas neste exemplo é feita em dois bytes: o primeiro corresponde ao código da instrução propriamente dita e o segundo à distância entre o endereço da próxima instrução e o endereço destino. No primeiro salto (linha 16) essa distância é de quatro bytes para a frente e no segundo é de oito bytes para trás (a que corresponde, em complemento para dois, a representação F8h). 3.3 Ciclos repetir() Um ciclo deste tipo caracteriza-se por ter o teste de controlo no fim de cada iteração pelo que o conjunto de instruções que encerra é sempre executado pelo menos uma vez. Repare-se no seguinte exemplo que 3

4 introduz a instrução jnz (jump if accumulator is not zero): 2 ; Ciclo repetir 4 ; do { 5 ; cont-- 6 ; } while(cont!=0); 7 ; cont=100; 8 ;==================================================================== dseg at 40h ; Segmento (absoluto) de dados cont: ds 1 ; Contador cseg at 0000h ; Segmento (absoluto) de código next1: dec cont 0002 E mov a,cont ; Teste da FA 17 jnz next1 ; condiç~ao de fecho do ciclo mov cont,#100 ; Atribuiç~ao final ; ou ent~ao, de forma ainda mais resumida D540FD 23 next2: djnz cont,next2 ; Decrementa, testa e repete 000C mov cont,#100 ; Atribuiç~ao final end 1. O teste de controlo do ciclo é feito no fim de cada iteração (linhas 16 e 17) por isso, ainda que a variável cont seja inicialmente nula, realiza-se sempre pelo menos uma iteração do ciclo. Neste exemplo concreto esse caso particular daria até origem a que se efectuassem 256 iterações já que, após a primeira, a variável cont passaria de zero para 255 e o ciclo só pararia quando cont voltasse a zero novamente. 2. A instrução djnz (linha 23) permite, neste caso particular, uma codificação alternativa muito eficiente. 3.4 Estruturas if then else As instruções de salto permitem uma implementação confortável deste tipo de estruturas nos programas escritos em assembly. O exemplo seguinte introduz as instruções ljmp (long jump) e cjne (compare and jump if not equal). 2 ; Teste de valores de 16 bits e de valores n~ao nulos 4 ; if(val==0) { 5 ; state++; 6 ; cont=maxcont; 7 ; } 8 ; else { 9 ; if(state==12) 10 ; state--; 11 ; } 12 ;==================================================================== 13 3A98 14 MAXCONT equ dseg at 40h val: ds 2 ; Ocupa 2 bytes cont: ds 2 ; Ocupa 2 bytes state: ds 1 ; Ocupa apenas 1 byte cseg at 0000h 0000 E mov a,val ; Pega no MSB e 4

5 orl a,val+1 ; conjuga com o LSB A 24 jz zero ; Salta se LSB=MSB= C 26 mov a,# B5440D 27 cjne a,state,done ; Compara state com 12, salta se diferente 000B dec state ; Faz state-- 000D ljmp done zero: inc state ; Faz state A 32 mov cont,#high(maxcont) ; Guarda MSB de MAXCONT mov cont+1,#low(maxcont) ; Guarda LSB de MAXCONT done: end 1. Repare-se na declaração da variável val (linha 17): uma vez que ocupa dois bytes o teste efectuado (linhas 22, 23 e 24) deve incluir ambos. 2. Nas linhas 32 e 33 foram utilizados dois operadores suportados pelo assemblador da Keil (high e low) que calculam, respectivamente, a metade mais significativa e menos significativa de um valor de 16 bits. 3. A instrução de salto incondicional ljmp (linha 29) não era aqui estritamente necessária pois, atendendo ao endereço destino do salto, bastaria utilizar a instrução sjmp. Ela está aqui por causa da sua tradução em código máquina: dos três bytes gerados o primeiro (02h) é o código da instrução propriamente dita enquanto que os dois seguintes (0018h) representam o endereço destino e não a distância do salto. Poderia ter sido utilizada a instrução virtual genérica jmp que teria neste caso como tradução os códigos da instrução sjmp. 3.5 Estruturas de escolha múltipla A instrução de comparação cjne permite também implementar estruturas de escolha múltipla semelhantes às que existem em linguagens de alto nível. Repare-se no exemplo seguinte: 1 ;=============================================================== 2 ; Escolha múltipla 4 ; switch (op) { 5 ; case 1: pin=10;break; 6 ; case 2: pin=50;break; 7 ; case 3: pin=250;break; 8 ; default: pin=0; 9 ; } 10 ;=============================================================== dseg at 40h op: ds pin: ds cseg at 0000h 0000 E mov a,op 0002 B cjne a,#1,not1 ; Compara com A 19 mov a,# F 20 sjmp done 0009 B Not1: cjne a,#2,not2 ; Compara com 2 000C mov a,#50 000E sjmp done 0010 B Not2: cjne a,#3,not Compara com FA 25 mov a,# sjmp done 0017 E4 27 Not3: clr a ; Default F done: mov pin,a end 5

6 1. A comparação (linhas 18, 21 e 24) não estraga o registo acumulador pelo que (linha 17) basta carregá-lo uma vez. 2. Novamente se nota nos códigos da instrução de comparação e salto (linhas 18, 21 e 24) a distância entre o endereço da próxima instrução e o endereço destino do salto, quatro bytes nos três casos deste exemplo. 3. A instrução mov final (linha 28) completa a execução. É sempre executada qualquer que seja a escolha feita. 4 Chamada e retorno de subrotinas As instruções de chamada de subrotinas 1 contribuem decisivamente para garantir uma boa estrutura dos programas, ao permitirem dividir uma tarefa complexa em tarefas mais simples, cada uma executada por uma rotina que em devido tempo será chamada. O exemplo seguinte apresenta as instruções de chamada lcall e acall, a instrução de retorno ret e a instrução nop (no operation). 2 ; Atraso configurável 4 ; delay(n) { 5 ; for(i=n;i<0;i--); 6 ; } 7 ; 8 ; delay(50); 9 ; delay(100); 10 ;==================================================================== cseg at 0000h F32 13 mov r7,# lcall delay ; delay(50) F64 15 mov r7,# acall delay ; delay(100) FE 17 stop: sjmp stop cseg at 0080h delay: nop ; N~ao faz nada nop ; a n~ao ser gastar algum tempo 0082 DFFC 22 djnz r7,delay ; Repete R7 vezes ret end 1. A codificação da instrução lcall (linha 14) é bastante mais simples e directa do que a da instrução acall (linha 16). Naquela aparece de forma evidente o endereço destino enquanto nesta parte do endereço é incorporada no código da instrução [1, páginas 17 e 36]. 2. Poderia ter sido utilizada a instrução virtual genérica call para substituir as instruções lcall e acall. Atendendo à proximidade da rotina, a instrução virtual seria traduzida, em ambos os casos, como se tratasse de uma instrução acall. 3. A instrução de salto (linha 17) é necessária para encravar o programa, caso contrário depois de executada a instrução da linha 16, a subrotina seria novamente executada mas no fim a stack ficaria corrompida por ter sido executado um ret sem previamente ter sido executado um acall ou lcall. 1 Os termos rotina e subrotina serão usados indistintamente para especificar um conjunto de instruções que executam uma tarefa específica no contexto da resolução de um problema mais abrangente. 6

7 5 Problemas Apresentam-se de seguida alguns problemas que requerem a utilização de instruções de salto e chamada de subrotinas. 1. Escreva um programa que calcule t = (a) são todos inferiores a 13, (b) são todos inferiores a i=0 y[i] supondo que os elementos do vector: Declare as variáveis num segmento de dados absoluto com início em 40h. 2. Traduza à mão, para código máquina, as duas soluções do problema anterior. 3. Escreva uma rotina que calcule a soma (efectuada sem considerar eventuais transportes) dos conteúdos de uma zona de memória com 32 bytes de comprimento e início apontado pelo registo R0. O resultado deve ficar no acumulador. Escreva um programa que chame essa rotina para somar os conteúdos da zona de memória com início no endereço 30h. 4. Escreva uma rotina que calcule o valor mínimo de uma zona de memória com início apontado pelo registo R0 e comprimento indicado no registo R7. No fim o mínimo deve ficar em R7. 5. Escreva a rotina testval que testa se o valor contido no acumulador é positivo, nulo ou negativo e incrementa, respectivamente, as variáveis np, nz e nn. 6. Considere o vector vv[ ], com 50 elementos de um byte cada, representados em complemento para dois. Com base na rotina desenvolvida no problema anterior escreva um programa que comece por fazer np = nz = nn = 0 e de seguida conte quantos elementos positivos, nulos e negativos existem no vector. Declare o vector e as variáveis num segmento de dados absoluto com início em 60h. 7. Escreva um programa que implemente na variável cont definida num segmento de dados absoluto com início em 30h um contador BCD (binary coded decimal) de dois dígitos. Considere os seguintes casos: (a) contagem crescente: 0, 1, 2,..., 99, 0, 1,..., (b) contagem decrescente: 99, 98,..., 2, 1, 0, 99, 98,.... Sugestão: consulte o manual de programação [1, página 27] para perceber como funciona a instrução da (decimal adjust) e utilize-a. 8. Suponha já existente a rotina upcase que converte para maiúscula a letra minúscula contida no acumulador devolvendo o resultado da conversão também no acumulador. (a) Escreva um programa que, recorrendo a essa rotina, converta para maiúsculas um texto com início apontado por R0 e cujo fim é indicado pelo código 0. (b) Escreva a rotina upcase. 9. Apresente duas rotinas diferentes (cjne, movc) para converter o valor contido no acumulador de acordo com a tabela 1. O resultado deve vir no acumulador. O valor É convertido em Tabela 1: Conversão de valores 7

8 10. Suponha já existente a rotina countbits que conta o número de bits a um da posição de memória apontada por R0, devolvendo o resultado no acumulador. (a) Escreva um programa que, recorrendo a essa rotina, conte o número de bits a um de uma zona de memória com início apontado pelo registo R0 e comprimento indicado no registo R7. O resultado deve ficar na variável nbits, declarada num segmento de dados absoluto. (b) Escreva a rotina countbits. Referências [1] Philips semiconductors; 80C51 family programmer s guide and instruction set; Setembro de [2] Yeralan, Senser and Ahluwalia, Ashutosh; Programming and Interfacing the 8051 Microcontroller; Addison Wesley, 1995; ISBN