Accueil
Démo
Exercices formatifs
Travaux pratiques
Simulation libre
Sessions sauvegardées

TP3: Branchements et appels de fonction

Ce travail pratique vaut 4% de la note totale du cours. Comme le stipule le plan de cours, le travail doit être fait individuellement.

Objectifs

Ce travail pratique vise les objectifs suivants:

  1. Comprendre comment sont effectués les transferts de programme d'une partie de la mémoire à une autre;
  2. Expérimenter avec l'appel de fonctions en assembleur ARM;
  3. Implémenter des algorithmes simples en assembleur ARM;
  4. Comprendre comment fonctionnent les branchements en assembleur ARM.

Ce TP s'effectue en deux étapes: écrire du code et répondre à des question. Chacune des étapes vaut 50% de la note totale.

Étape 1: code (50% de la note)

Dans cette étape, vous aurez à implémenter 3 fonctions: EchangeRegistres, EstPair et CopieMemoire.

Fonction EchangeRegistres

La fonction EchangeRegistre échange le contenu des registres R0 et R1. Elle doit le faire sans modifier le contenu des autres registres. Le code suivant (disponible dans le code fourni) vous permettra de tester le fonctionnement de votre fonction:

MOV R0, #5
MOV R1, #10
BL EchangeRegistres
ASSERT R0=10,R1=5

Après l'exécution de l'instruction BL EchangeRegistres, R0 devrait contenir 10 et R1 devrait contenir 5. Si ça n'est pas le cas, vous observerez une erreur sur le ASSERT.

Fonction EstPair

La fonction EstPair détermine si le nombre placé dans R0 est pair ou non. S'il est pair, elle place 1 dans le registre R2. S'il est impair, elle place 0 dans le registre R2. Comme pour la fonction EchangeRegistre, le code fourni contient du code pour vous permettre de tester votre fonction EstPair. Assurez-vous qu'elle fonctionne correctement avant de passer à la prochaine étape.

Fonction CopieMemoire

La fonction CopieMemoire doit copier une partie de la mémoire vers un autre emplacement. Cette opération est analogue à celle que fait votre ordinateur au démarrage, lorsqu'il copie d'abord une partie du système d'exploitation dans la RAM depuis votre disque dur, avant de laisser le contrôle au système en faisant un branchement vers les instructions fraichement copiées.

La fonction CopieMemoire reçoit les paramètres suivants:

  • R0: Adresse du premier mot de 32 bits à copier.
  • R1: Adresse du dernier mot de 32 bits à copier.
  • R2: Adresse de destination.

Votre fonction doit fonctionner correctement si l'adresse du dernier mot est plus petite que celle du premier mot. Dans ce cas, aucun mot ne devrait être copié. De même, si l'adresse du dernier mot est la même que celle du premier mot, un seul mot devrait être copié. Testez ces cas vous-mêmes pour vous assurer que votre fonction respecte bien ces critères!

Votre code doit contenir au moins un commentaire toutes les trois lignes de code assembleur, qui décrit le fonctionnement de votre programme.

Important: votre fonction CopieMemoire ne doit pas modifier le contenu des registres. Cela inclut R0, R1, et R2, qui sont utilisés pour passer des arguments à la fonction, et tout autre registre que vous déciderez d’utiliser. Indice : vous disposez d’une pile de 32 octets, elle pourrait vous être fort utile!

Dans ce TP, n'utilisez jamais les registres R7, R8, R9 et R10. Si ces registres sont modifiés, il est possible que le reste du code ne fonctionnera pas.

Afin de vous aider à déboguer votre code, il vous est possible de placer un point d'arrêt («breakpoint») directement dans la mémoire (plutôt que sur une ligne de l'éditeur de texte). Pour ce faire, cliquez sur la case mémoire correspondante tout en maintenant la touche «alt» enfoncée.

Lorsque vous avez terminé, téléchargez tout d'abord votre fichier source.txt sur votre ordinateur grâce au bouton «télécharger» dans le simulateur, puis téléversez ce même fichier dans la boîte de dépôt qui est disponible sur le portail des cours.

Étape 2: questions (50% de la note)

Une fois vos fonctions implémentées et testées, vous devez répondre à des questions sur le portail des cours. Chacune de ces questions est associée à un commentaire dans le code fourni qui marque l'instruction, la déclaration ou la ligne sur laquelle porte la question. Attention de ne pas effacer ces commentaires en éditant le code fourni. Contrairement au TP2, vous pouvez ajouter votre code sans craindre que cela n'affecte les réponses aux questions demandées.

Le questionnaire est disponible sur le portail des cours. N'oubliez pas de cliquer sur «soumettre»! Pour toutes questions concernant la procédure de remise ou le travail lui-même, utilisez Piazza!

Liens importants

Remerciements

Merci à Étienne Tremblay d'avoir créé le TP original qui a servi d'inspiration pour celui-ci. Merci à Marc-André Gardner pour l'élaboration de la version «ENA» du TP. Finalement, merci à Marc-André Gardner et à Yannick Hold-Geoffroy pour le simulateur ARM! Merci à Jessica Déziel pour le design graphique.

Registre Généraux (User)

Nom Valeur
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13 (sp)
R14 (lr)
R15 (pc)

Registre Généraux (FIQ)

Nom Valeur
R0
R1
R2
R3
R4
R5
R6
R7
R8 FIQ
R9 FIQ
R10 FIQ
R11 FIQ
R12 FIQ
R13 FIQ (sp)
R14 FIQ (lr)
R15 (pc)

Registre Généraux (IRQ)

Nom Valeur
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13 IRQ (sp)
R14 IRQ (lr)
R15 (pc)

Registre Généraux (SVC)

Nom Valeur
R0
R1
R2
R3
R4
R5
R6
R7
R8
R9
R10
R11
R12
R13 SVC (sp)
R14 SVC (lr)
R15 (pc)

État courant

 CPSRSPSR
Negatif (N)
Zero (Z)
Retenue (C)
Dépassement (V)
Ignore IRQ
Ignore FIQ

Configurations

Interruptions

Activer
Type
 cycles
 cycles (premier)
Vitesse d'exécution :  ms

Français

SECTION INTVEC B main SECTION CODE ; Question 1 adresseDebut ; ------------------------------------------------------------------------ ; Fonction fonctionMystere ; ------------------------------------------------------------------------ ; Question 2 fonctionMystere MOV R0, #0 ; Question 3 MOV R1, #0x80000000 ; Question 4 LSR R1, R1, #20 ; Question 5 ASR R1, R1, #11 ; Question 6 ADD R7, PC, #-4 boucleInterne ; Question 7 ADDS R0, R0, R1 MRS R10, CPSR ; Question 8 MOV LR, PC BX R8 ; Ne _jamais_ modifier le registre R10 MSR CPSR, R10 ; Question 9 et 10 MOVCS R0, #0 MOVCS R1, #1 MOV LR, PC BX R9 CMP R2, #1 ADDEQ R0, R0, #1 ; Question 11 adresseFin MOV PC, R7 ; ------------------------------------------------------------------------ ; Fin de la fonction fonctionMystere ; ------------------------------------------------------------------------ ; ------------------------------------------------------------------------ ; Code principal ; ------------------------------------------------------------------------ main ; Préparons une pile LDR SP, =maPile ; Question 12 ADD SP, SP, #32 ; Test de la fonction EchangeRegistres MOV R0, #5 MOV R1, #10 BL EchangeRegistres ASSERT R0=10,R1=5 ; Ne pas enlever cette ligne: ${TEST_ER} ; Test #1 de la fonction EstPair MOV R0, #5 BL EstPair ASSERT R2=0 ; Test #2 de la fonction EstPair MOV R0, #10 BL EstPair ASSERT R2=1 ; Ne pas enlever cette ligne: ${TEST_EP} ; Test de la fonction CopieMemoire LDR R0, =varTestCopieMemoire ADD R1, R0, #0x8 LDR R2, =espaceTestCopieMemoire BL CopieMemoire ASSERT 0x1010=0x67,0x1011=0x45,0x1012=0x23,0x1013=0x01 ASSERT 0x1014=0xAB,0x1015=0x89,0x1016=0x67,0x1017=0x45 ASSERT 0x1018=0xBC,0x1019=0x9A,0x101A=0x78,0x101B=0x56 ASSERT 0x101C=0x00,0x101D=0x00,0x101E=0x00,0x101F=0x00 ; Ne pas enlever cette ligne: ${TEST_CM} ; Copier EchangeRegistres en mémoire LDR R0, =EchangeRegistres LDR R1, =FinEchangeRegistres LDR R2, =echangeRegistresEnRAM BL CopieMemoire ; Test de EchangeRegistres en mémoire MOV R0, #98 MOV R1, #35 BL echangeRegistresEnRAM ASSERT R0=35,R1=98 ; Copier EstPair en mémoire LDR R0, =EstPair LDR R1, =FinEstPair LDR R2, =estPairEnRAM BL CopieMemoire ; Test de EstPair en mémoire MOV R0, #12 BL estPairEnRAM ASSERT R2=1 ; Charger l'adresse de fonctions dans R8 et R9 ; NE PAS MODIFIER R8, R9, NI R10! LDR R8, =echangeRegistresEnRAM LDR R9, =estPairEnRAM ; Effectuer une copie mémoire LDR R0, =CopieMemoire LDR R1, =FinCopieMemoire LDR R2, =copieMemoireEnRAM ; Question 13 BL CopieMemoire ; Effectuer une copie mémoire ; Question 14 LDR R0, =adresseDebut LDR R1, =adresseFin LDR R2, =fonctionEnRAM ; Question 15 et 16 BL copieMemoireEnRAM ; Question 17 MOV PC, R2 ; ------------------------------------------------------------------------ ; Fin du code principal ; ------------------------------------------------------------------------ ; ------------------------------------------------------------------------ ; Fonction EchangeRegistres ; ------------------------------------------------------------------------ EchangeRegistres ; La fonction EchangeRegistres échange les registres R0 et R1, sans ; toutefois modifier le contenu d'autres registres. ; Écrivez le code de votre fonction EchangeRegistres ici. FinEchangeRegistres ; ne rien écrire entre FinEchangeRegistres et BX LR BX LR ; ------------------------------------------------------------------------ ; Fin de la fonction EchangeRegistres ; ------------------------------------------------------------------------ ; ------------------------------------------------------------------------ ; Fonction EstPair ; ------------------------------------------------------------------------ EstPair ; La fonction EstPair détermine si le nombre placé dans R0 est pair ou non. ; S'il est pair, elle place 1 dans R2. ; Sinon, elle place 0 dans R2. ; Écrivez le code de votre fonction EstPair ici. FinEstPair ; ne rien écrire entre FinEstPair et BX LR BX LR ; ------------------------------------------------------------------------ ; Fin de la fonction EstPair ; ------------------------------------------------------------------------ ; ------------------------------------------------------------------------ ; Fonction CopieMemoire ; ------------------------------------------------------------------------ CopieMemoire ; La fonction CopieMemoire reçoit les paramètres suivants: ; R0: Première adresse à copier ; R1: Dernière adresse à copier ; R2: Adresse de destination (celle où vous devez écrire/copier ; les instructions) ; Écrivez le code de votre fonction CopieMemoire ici. FinCopieMemoire ; ne rien écrire entre FinCopieMemoire et BX LR BX LR ; ------------------------------------------------------------------------ ; Fin de la fonction CopieMemoire ; ------------------------------------------------------------------------ SECTION DATA stockageTemporaire1 ALLOC32 1 varTestCopieMemoire ASSIGN32 0x01234567, 0x456789AB, 0x56789ABC espaceTestCopieMemoire ALLOC32 3 stockageTemporaire2 ASSIGN32 0 ; Espace mémoire pour les fonctions echangeRegistresEnRAM ALLOC32 16 estPairEnRAM ALLOC32 16 copieMemoireEnRAM ALLOC32 32 ; Question 18 fonctionEnRAM ALLOC32 32 ; Question 19 maPile ALLOC32 8 ; Ne pas enlever cette ligne: ${TEST_DATA}

Instruction courante

Mémoire

Suivre PC
Cycle courant :