Assembly Saltos e Subrotinas

Transcrição

1 Aula 6 Assembly Saltos e Subrotinas 6.1 Objectivos Introdução Ciclos e outras estruturas de controlo Ciclos Estruturas if then else Escolha múltipla Subrotinas Escolha automática de instruções Utilização de segmentos recolocáveis Problemas Objectivos Consolidação de conhecimentos sobre a linguagem assembly da família 51. Familiarização com as instruções de salto e chamada de subrotinas. Utilização da pilha (stack) e respectivo apontador (stack pointer). 6.2 Introdução Conclui-se com este guião uma breve introdução à linguagem assembly da família 51. Apresentam-se aqui diversos problemas que obrigam à utilização de instruções de salto e à organização do código em subrotinas. Estude com cuidado os exemplos apresentados e as consideraçõ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. 1

2 2 AULA 6. ASSEMBLY SALTOS E SUBROTINAS 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 responsabilidades que o programador deve assumir. Felizmente é fácil implementar algumas estruturas de controlo existentes em linguagens de alto nível recorrendo a instruções de salto Ciclos A maneira mais fácil de controlar a execução de determinado grupo de instruções um número constante de vezes é utilizando a instrução DJNZ (decrement and jump if not zero) que admite como operando um registo ou um endereço de memória de dados interna: LOC OBJ LINE SOURCE 1 ;============================================== 2 ; Inicializaç~ao de um vector em memória 3 ; for(i=0;i<16;i++) { 4 ; temp[i]=0 5 ; } 6 ; jpsousa@fe.up.pt 7 ;============================================== SIZE equ 16 ; Tamanho do vector dseg at 40h temp: ds SIZE cseg at mov r0,#temp ; Endereço inicial 0002 E4 16 clr a F10 17 mov r7,#size ; Tamanho 0005 F6 18 next: ; Inicializa posiç~ao inc r DFFC 20 djnz r7,next end Repare-se, a propósito deste exemplo, na utilizaçã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ções que a variável ocupa. Um ciclo pode também 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ções 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ções nele incluído é executado pelo menos uma vez: LOC OBJ LINE SOURCE 1 ;======================================= 2 ; Ciclo do tipo enquanto...

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 ; jpsousa@fe.up.pt 11 ;======================================= dseg at 40h y: ds x: ds cseg at E tst: mov a,x ; Testa em A F 19 jz done ; Acaba se A= ; Multiplica por 2 um número de 16 bits 0004 C3 22 clr c 0005 E mov a,y+1 ; Processa LSB rlc a 0008 F mov y+1,a 000A E mov a,y ; Processa MSB 000C rlc a 000D F mov y,a F dec x ED 31 sjmp tst done: ;======================================= 38 ; Ciclo do tipo repetir ; unsigned char x; 40 ; unsigned int y; 41 ; 42 ; do { 43 ; y=2*y; 44 ; x--; 45 ; } while (x!=0); 46 ; jpsousa@fe.up.pt 47 ;======================================= cseg at 0100h E next: mov a,y+1 ; Processa LSB E0 52 add a,acc 0104 F mov y+1,a 0106 E mov a,y ; Processa MSB rlc a 0109 F mov y,a B D542F2 58 djnz x,next end Repare-se que o teste que determina o fim do ciclo (linha 19) é específico do acumulador pelo que não chega decrementar a variável de controlo (linha 30) mas é necessário copiá-la para o acumulador (linha 18). Já no segundo caso (linha 58) o teste é efectuado directamente sobre a variável de controlo.

4 4 AULA 6. ASSEMBLY SALTOS E SUBROTINAS Estruturas if then else As instruções de salto permitem uma implementaçã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 ; 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 ; } jpsousa@fe.up.pt 13 ;======================================= 14 3A98 15 MAXCNT equ dseg at 50h cont: ds val: ds state: ds cseg at 0h 0000 E mov a,val orl a,val A 25 jnz nzero inc state mov cont,#low(maxcnt) ; LSB 000B 75513A 28 mov cont+1,#high(maxcnt) ; MSB 000E sjmp done C 30 nzero: mov a,# B cjne a,state,done dec state done: 34 Algumas considerações sobre o exemplo apresentado: 1. Uma vez que a variável 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 assemblador (low e high) que calculam, respectivamente, a metade menos significativa e mais significativa de um valor de 16 bits. 3. Repare-se finalmente nos códigos das instruções de salto utilizadas neste exemplo (linhas 24, 28 e 30) o último byte de cada instrução representa a distância entre o endereço da próxima instrução e o endereço destino do salto; respectivamente 10, 7 e 2 bytes. Nem todas as instruções de salto são relativas, algumas indicam de modo absoluto o endereço destino.

5 6.4. SUBROTINAS 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: LOC OBJ LINE SOURCE 1 ;======================================= 2 ; Escolha múltipla 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 ; jpsousa@fe.up.pt 10 ;======================================= dseg at 50h op: ds pin: ds cseg at 100h 0100 E mov a,op 0102 B cjne a,#0,not0 ; A = 0? mov a,# sjmp Done 0109 B Not0: cjne a,#9,not9 ; A = 9? 010C 74C8 22 mov a,# E sjmp Done 0110 E4 24 Not9: clr a ; default F Done: mov pin,a end Algumas considerações sobre o exemplo apresentado: 1. A comparaçã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ção de comparação e salto (linhas 18 e 21) a distância entre o endereço da próxima instrução e o endereço destino do salto, 4 bytes nos dois casos deste exemplo. 3. A instrução MOV (linha 25) completa a execução. É sempre executada qualquer que seja a escolha feita. 6.4 Subrotinas As instruções de chamada de subrotinas 1 contribuem decisivamente para a 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. 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 6 AULA 6. ASSEMBLY SALTOS E SUBROTINAS LOC OBJ LINE SOURCE 1 ;======================================= 2 ; Atraso configurável 3 ; 4 ; delay(n) { 5 ; for(i=n;i>0;i--); 6 ; } 7 ; delay(50); 8 ; delay(100); 9 ; jpsousa@fe.up.pt 10 ;======================================= cseg at F32 13 mov r7,# lcall delay F64 15 mov r7,# D acall delay FE 17 stop: sjmp stop cseg at 0680h delay: nop ; Par^ametro de entrada em r nop 0682 DFFC 22 djnz r7,delay ; Repete R7 vezes ret end Algumas considerações sobre o exemplo apresentado: 1. A codificação manual 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. A instrução de salto é necessária para encravar o programa, caso contrário depois de executada a instruçã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ática de instruções A escolha de uma entre as três instruções de salto incondicional que esta família suporta (ljmp, ajmp e sjmp) faz-se em funçã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ção a mnemónica genérica jmp que o próprio assemblador escolherá a instrução mais indicada das três. O mesmo se passa relativamente à chamada de subrotinas: basta utilizar a mnemónica genérica call que o assemblador escolherá a instrução lcall ou acall dependendo da distância a que estiver a rotina que se pretende chamar.

7 6.6. UTILIZAÇÃO DE SEGMENTOS RECOLOCÁVEIS Utilização de segmentos recolocáveis A utilização de segmentos absolutos, já abordada anteriormente [3], tem a grande desvantagem obrigar a um grande cuidado na sua utilização para garantir a inexistência de sobreposições entre segmentos do mesmo tipo. Para evitar esse trabalho e facilitar a reutilizaçã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ço inicial pois ele é definido pelo linker, isto é, depois da compilação. A figura 6.1 ilustra as fases necessárias à criaçã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ção das instruções. O processo de codificação é completado pelo linker antes da geração do ficheiro executável. Assemblador / Compilador Assemblador / Compilador Linker Ficheiro executável Ficheiros fonte Assemblador / Compilador Ficheiros objecto Figura 6.1: Processo de geração de um ficheiro executável A definição de um segmento recolocável faz-se com o comando segment e a sua activação com o comando rseg. O exemplo ilustra a sintaxe: rotinas segment code mensagens segment code vars segment data vars2 segment xdata ; Segmento recolocável em MP ; Segmento recolocável em MP ; Segmento recolocável em MDI ; 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ço 0.. ; --- Rotinas de E/S rseg rotinas ; Activa o segmento rotinas... ; === Mensagens do sistema ============================================= rseg mensagens ; Activa o segmento mensagens pin_msg: DB "Introduza o PIN: " ; Preenche 7 bytes algures em MP

8 8 AULA 6. ASSEMBLY SALTOS E SUBROTINAS No exemplo apresentado, a única conclusão que se pode tirar quanto a endereços é que o programa principal começa no endereço 0000h da memória de programas pois é o único segmento absoluto existente. Os endereços dos segmentos recolocáveis são definidos mais tarde, automaticamente, durante o processo de geração do código máquina. 6.7 Problemas Apresentam-se de seguida alguns problemas que requerem a utilização de instruções de salto e/ou de chamada de subrotinas. 1. Escreva um programa que calcule t = 19 i=0 y[i] supondo que: (a) os elementos do vector são todos inferiores a 13, (b) os elementos do vector são todos inferiores a 256. Declare as variáveis num segmento de dados absoluto com início em 30h. 2. Escreva um programa que implemente na variável Cont definida num segmento de dados recolocável um contador cíclico de 24 bits. Considere dois casos: (a) contagem crescente: 0, 1, 2,..., , 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ções do problema anterior. 5. Escreva um programa que calcule a soma de controlo simples (soma efectuada sem considerar eventuais transportes) de uma zona de 256 bytes de memória com início apontado pelo registo R0. No fim: R0 fica a apontar para um endereço 256 posições 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ória 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. 7. Suponha já existente a rotina Upcase que converte para maiúscula a letra minúscula cujo código ASCII está no acumulador, devolvendo o resultado da conversão também no acumulador.

9 6.7. PROBLEMAS 9 (a) Escreva um programa que, recorrendo a essa rotina, converta para maiúsculas um texto em MDI com início apontado por R0 e cujo fim é indicado pelo código 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úmero de bits a um de uma zona de memória da dados interna com início apontado pelo registo R0 e comprimento indicado no registo R7. O resultado deve ficar em R7. (b) Escreva a rotina CountBits.

10 10 AULA 6. ASSEMBLY SALTOS E SUBROTINAS

11 Referências [1] Philips semiconductors; 80C51 family programmer s guide and instruction set; Setembro de [2] Ferreira, José Manuel; Resumo das instruções do 80C51 ; FEUP, Setembro de [3] Sousa, João Paulo; Assembly: Primeiros passos; FEUP, Setembro de [4] Atmel Wireless and Microcontrollers; 89C51 data sheet; Setembro de [5] Ferreira, José Manuel; Introdução ao Projecto com Sistemas Digitais e Microcontroladores; FEUP Edições, 1998, ISBM