TP Soclib Riscv

Télécharger au format pdf ou txt
Télécharger au format pdf ou txt
Vous êtes sur la page 1sur 3

e2i5

TP : Mise en œuvre
du simulateur SoCLib et
du compilateur GCC pour RISC-V

L’objectif de la séance de TP est de vérifier et de mettre en œuvre les différents


concepts étudiés en cours sur l’architecture du processeur RISCV et sa programmation.
Le compilateur est une version de gcc pour le RISCV. Le simulateur est issu de
l’environnement SoCLiB (https://gitlab.com/soclib/soclib) et spécialisé pour le RISCV dans
la version installée en salle 216.
A noter que le processeur RISCV du simulateur supporte la multiplication et les
nombres virgule flottante à simple précision.

Le TP se décompose en plusieurs parties :


• Appel de fonctions et convention RISCV sur les registres et le passage des paramètres
en langage d’assemblage,
• Simulation et débogage en mode pas à pas avec gdb
• Étude de la pile pour une fonction récursive,
• Étude du code généré par le compilateur,
• Étude des instructions 16 bits.

1 – Environnement de projet

Vous trouverez dans le répertoire Partage/ un répertoire projet-RISCV/ contenant plusieurs


répertoires et fichiers. Le répertoire main/ contient 2 fichiers : main.s et Makefile.
• Le fichier main.s contient une fonction main et les fonctions que vous écrirez.
• Le fichier Makefile contient la liste des fichiers à compiler (ligne SRCS), fichier .s ou .c
• La commande make permet de compiler votre projet et de produire l’exécutable dont le
nom est indiqué dans le fichier Makefile, ligne TRGT.

Recopier sur votre compte TOUT le répertoire projet-RISCV/.


Le fichier main.s contient le programme principal et la fonction factorial_i vide. Vérifier en
lançant la commande make que le fichier ne contient pas d’erreur.

Important : Dans chaque terminal sur lequel vous allez travailler, exécuter la commande
setenv_soclib une fois à l’ouverture du terminal. Cette commande mettra à jour les variables
d’environnement nécessaires au bon déroulement de ce TP.

2 – Fonctions de bibliothèque

Des fonctions de bibliothèque sont disponibles, notamment pour l’affichage.

• En langage d’assemblage RISCV, les fonctions d’affichage suivantes sont disponibles :


puts (chaîne de caractères), putchar (1 caractère), putx (entier en hexa), putd (entier signé
décimal), putu (entier non signé). La fonction getchar (code ASCII touche clavier, 1 seul
caractère) permet de récupérer un caractère au clavier par l’utilisateur.
• En langage C, la fonction printf n’est pas disponible. Seules les fonctions suivantes sont
disponibles : puts, putx, putd et strcpy, memset, memcpy, strchr.
e2i5

3 – Compilation, assemblage et édition de lien

La commande make permet de lancer la compilation ou l’assemblage, et l’édition de liens.


Deux fichiers sont produits : l’exécutable (par défault main.x) et un fichier elf (main.x.dump)
éditable qui contient une description le code produit avec toutes les informations de codage
des instructions, des adresses et des appels de fonctions.

4 – Appel du simulateur

Voici la commande permettant d’appeler le simulateur avec un exécutable de nom


pgm_exec.x. La commande SOCLIB_GDB=F avant l’appel au simulateur permet de lancer
la simulation avec un point d’arrêt sur la 1ière instruction du programme complet.
SOCLIB_GDB=F simulator-rv32-multi --soft pgm_exec.x

• Sous gdb, la commande c permet de continuer l’exécution jusqu’à la fin.


• Pour faire de la simulation pas à pas, il faut lancer un 2ième terminal, puis les commandes
suivantes dans ce nouveau terminal :
o riscv-rtems5-gdb pgm_exec.x
o (gdb) target remote :numport (par défaut, numport = 2346, sinon le
trouver dans la fenêtre du simulateur)
o (gdb) b main pour mettre un breakpoint sur l’étiquette main
o (gdb) c pour continuer jusqu’au breakpoint
o (gdb) si step instruction pour avancer pas à pas
o (gdb) set $a0=6 pour changer la valeur du registre a0
o (gdb) tui enable pour appeler une fenêtre de débug avec le code ASM
o (gdb) info register pour afficher le contenu des registres
o (gdb) display $t0 permet à chaque si d’afficher le contenu du registre t0
o (gdb) print $sp
o (gdb) x /10x $sp pour afficher les 10 valeurs en hexa contenues dans la pile
o (gdb) print $pc pour connaître l’adresse de l’instruction en cours
d’exécution.

5 – Validation de la fonction factorielle itérative

• Dans le fichier main.s, insérer le code de votre fonction en langage d’assemblage à


l’étiquette prévue, ou modifier l’appel dans le main à la fonction. Compiler, exécuter et
vérifier le fonctionnement de votre programme.

6 – Validation de la fonction factorielle récursive

• Dans le fichier main.s, insérer le code de votre fonction en langage d’assemblage à


l’étiquette prévue (et dé-commenter l’appel dans le main et l’affichage du résultat), ou
modifier l’appel dans le main à la fonction. Compiler, exécuter et vérifier le
fonctionnement de votre programme. Étudier le contenu de la pile en pas à pas.
• Trouvez la limite de la valeur de n pour le calcul de factoriel.

7 – Passage des paramètres par la pile


e2i5

• On cherche maintenant à modifier la fonction factoriel_r et printf_result pour ne plus


utiliser le registre a0 pour passer le paramètre. Le paramètre est alors passée dans la pile.
Il faut donc prévoir un mot de plus dans la pile, stocker cette valeur avant d’appeler la
fonction. Dans la fonction, il faut aller lire la valeur du paramètre dans la pile de la
fonction appelante.

8 – Résultat produit par gcc

• Ecrire un programme C qui appelle par exemple la fonction factorielle récursive.

int factoriel_recursif(int n) ;

volatile int n = 10 ;

int main()
{
putd(factoriel_recursif(n)) ;
return 0 ;
}

int factoriel_recursif(int n)
{
if (n < 2)
return 1;
else
return (n * fact_rec(n – 1));
}

• Modifier le fichier Makefile pour mettre l’option -O3 pour gcc. Observer le code
assembleur produit. Qu’y t-il de remarquable ?
• Utiliser le simulateur pour vérifier le bon fonctionnement.

9 – Instructions compressées 16 bits

Dans le fichier compiler.mk, changer la ligne CPUFLAGS pour prendre la ligne commentée
au-dessus. On valide alors l’utilisation des instructions compressées 16 bits.
• Observer le code généré avec les instructions 16 bits et simuler le programme.

Vous aimerez peut-être aussi