Labo jeux d`instructions - Première partie (v2016.1.3)

Programmation assembleur (ASM)
Rick Wertenbroek / Magali Frölich / Daniel Rossier
Jeux d'instructions (première partie)
Jeudi 20 octobre 2016
Echéance: mardi 8 novembre 2016, 23h59
- 1 -
labo inst-part-1
(v2016.1.3)
Objectif du laboratoire
Ce laboratoire permet d'aborder les instructions de traitement en assembleur x86 et ARM . Il s'agira
également de se familiariser avec les cartes de référence rapide et d'examiner les différences entre un
code assembleur original et le résultat d'une compilation.
Consignes de laboratoire
Le laboratoire est évalué selon les conditions établies dans le document annexe qui vous a été
distribué en début de semestre.
Etape no. 1 - Opérations arithmétiques et logiques
a)
En supposant que le registre edx soit utilisé pour stocker la valeur d'un registre de périphérique,
réalisez le code suivant en assembleur
x86 . Pour cela utilisez le fichier labo3/x86/asmA1.S
void config_register(void) {
volatile int gpio_reg = 0x4600;
/* On suppose que la variable gpio_reg contient la valeur du registre… */
gpio_reg |= 0x2;
gpio_reg &= ~0x6;
gpio_reg ^= 0x8;
gpio_reg = (gpio_reg & ~0x38) | (0x6 << 3);
}
b) Créez le fichier C
labo3/x86/c_A1.c , copiez le code ci-dessus et compilez-le pour l'architecture cible
x86 ( 32 bits). Désassemblez le code binaire en utilisant l'application objdump de la toolchain
correspondante et comparez le résultat avec votre travail réalisé à l’étape a). Le code désassemblé
devra être copié et commenté (indiquez les différences avec votre version) dans
labo3/x86/disass.S .
Vous devrez rendre les deux fichiers sur bitbucket . Veillez à respecter la structure du dossier :
votre code source assembleur : labo3/x86/asmA1.S
le code désassemblé avec vos commentaires : créez et complétez le fichier
labo3/x86/disass.S
Indications
Adaptez le Makefile existant afin d'inclure votre fichier C.
Respectez l'ordre des opérations proposées !

ASM – Jeux d'instructions (première partie)
- 2 -
c) A l'aide de l'application objdump de la toolchain correspondante ou du debugger. Examinez les
instructions x86 produites par la compilation du fichier labo3/x86/c_A1.c et expliquez comment
l'opérateur ~ a été traduit. Rapportez ce que vous avez observé dans votre rapport README.md.
d) Répétez les étapes précédentes en assembleur ARM cette fois-ci. Utilisez le registre r8 pour stocker
la valeur du registre de périphérique. Note : Le répertoire de travail est labo3/arm/.
 Vous devrez rendre les deux fichiers sur bitbucket. Veillez à respecter la structure du dossier :
 votre code source assembleur : labo3/arm/asmA1.S
 le code désassemblé avec vos commentaires : créez et complétez le fichier
labo3/arm/disass.S
Etape no. 2 - Distance de Hamming
a) La distance de Hamming est une notion mathématique, définie par Richard Hamming, et utilisée en
informatique, en traitement du signal et dans les télécommunications. Elle permet de quantifier la
différence entre deux séquences de symboles. C'est une distance au sens mathématique du terme. À
deux suites de symboles de même longueur, elle associe le nombre de positions où les deux suites
diffèrent. - https://fr.wikipedia.org/wiki/Distance_de_Hamming
Dans le dossier x86, éditez le fichier asmA2.S et implémentez la distance de Hamming. Elle devra
calculer la distance de Hamming entre (le contenu de) deux registres et passera le résultat dans la
valeur de retour du programme.
Indications
 On cherche le nombre de bits qui diffèrent dans les séquences de bits de deux registres. Donc
une valeur entre 0 et 32 pour deux registres 32 bits.
 Pour cette étape, vous aurez besoin de quelques instructions de saut. Aidez-vous des cartes de
référence rapide afin de trouver les bonnes instructions.
b) Faites de même en assembleur ARM dans le dossier labo3/arm/.
 Vous devrez rendre les deux fichiers remplis et commentés sur bitbucket.
Veillez à respecter la structure du dossier :
 asm_student/labo3/x86/asmA2.S
 asm_student/labo3/arm/asmA2.S
Question Bonus :
Lors de cette étape nous avons considéré les symboles binaires. Donc issus de l’alphabet {0,1}.
Répétez l’exercice mais cette-fois considérez l’alphabet sur 8 bits. Un registre représente maintenant
4 symboles faisant partie de l’alphabet {0x00, 0x01, 0x02, … , 0xFF} (ce qui équivaut un caractère
ASCII 8-bit). La distance de Hamming entre deux registres 32 bits pour cet alphabet sera donc comprise
entre 0 et 4.
Le fichier rendu sera asmBonus.S (dans le dossier asm_student/labo3/x86/ pour une version x86 ou
asm_student/labo3/arm/ pour une version ARM).