Contenu
Jeu d'instructions
Ce processeur, inspiré des microprocesseurs ARM Cortex, dispose d'un banc de 8 registres de 16 bits. Pour simplifier sa conception, il dispose d'un registre à part pour le compteur ordinal. Son architecture est de type RISC (Reduced Instruction Set), load/store (seules les instructions de chargement et d'écriture de registre accèdent à la mémoire), et dispose d'instructions arithmétiques à 3 adresses (un registre pour le résultat, un registre pour chacun des opérandes).
Pour simplifier sa conception, les instructions tiennent sur un mot de 16 bits lorsqu'elle utilisent l'adressage par registre, et sur 2 mots de 16 bits lorsqu'elles utilisent l'adressage immédiat (opérations arithmétiques) ou direct (branchement), la valeur de l'opérande étant stockée dans le mot qui suit le code de l'instruction. Dernière entorse aux principes des RISC, ce processeur dispose d'un registre d'état qui mémorise le résultat des comparaisons.
Le jeu d'instructions est le suivant :
| Mnémonique | Description |
|---|---|
| ldr rx,[ry] | charge le registre rx avec le contenu de la mémoire à l'adresse contenue dans ry |
| ldr rx,adresse | charge le registre rx avec le contenu de la mémoire à l'adresse adresse |
| str rz,[ry] | écrit le contenu du registre rz en mémoire à l'adresse contenue dans ry |
| str rz,adresse | écrit le contenu du registre rz en mémoire à l'adresse adresse |
| mov rx,ry | charge la valeur du registre ry dans le registre rx |
| mov rx,#val | charge la valeur immédiate val dans le registre rx |
| add rx,ry,rz | charge le registre rx avec la somme des registres ry et rz |
| add rx,ry,#val | charge le registre rx avec la somme du registre ry et de val |
| sub rx,ry,rz | charge le registre rx avec la différence des registres ry et rz |
| sub rx,ry,#val | charge le registre rx avec la différence du registre ry et de val |
| cmp ry,rz | change les indicateurs N et Z du registre d'état en fonction de la différence ry-rz |
| cmp ry,#val | change les indicateurs N et Z du registre d'état en fonction de la différence ry-val |
| beq rz | saute à l'adresse contenue dans rz si le bit Z du registre d'état vaut 1 |
| beq address | saute à l'adresse address si le bit Z du registre d'état vaut 1 |
| blt rz | saute à l'adresse contenue dans rz si le bit N du registre d'état vaut 1 |
| blt address | saute à l'adresse address si le bit N du registre d'état vaut 1 |
| b rz | saute à l'adresse contenue dans rz |
| b address | saute à l'adresse address |
Programmes de test
Un assembleur est disponible pour traduire les mnémoniques en code machine. Cet assembleur permet de définir des étiquettes afin de faciliter l'écriture des branchements.
Cet assembleur est très rustique et ne donne pas de message très explicite en cas d'erreur. Quand il parvient à assembler le fichier source, il produit un fichier .lst qui reprend le code source en face du code généré, et un fichier .mem à charger dans le composant mémoire de Logisim.
Voici un petit programme de test pour vérifier le fonctionnement du processeur :
%
% Program for testing the mini ARM
%
% It should stop by looping at address 0x0020 (label 'end')
% If it stops at another address, there is a bug...
%
mov r0,#5 % load 5 into r0
str r0, var % store 5 in var
ldr r1, var % load var into r2
cmp r1,r0 % did we read the same value?
beq okls
@errls b errls % no => loop here
@okls add r2,r1,r1 % r2 <- 2*r1
cmp r2,r1 % is r2 < r1
blt err1 % yes => error
b ok1 % no, continue
@err1 b err1 % loop here
@ok1 cmp r1,#5 % is r1 = 5
beq ok2 % yes, it's ok
@err2 b err2 % no => error, loop here
@ok2 sub r3,r1,r2 % r3 <- r1-r2
cmp r3,#0 % is r3 < 0
blt end % yes => ok
@err3 b err3 % no => error, loop here
@end b end % end of program, loop here
@var rmw 1 % reserve a word for a variable
L'assembleur reconnaît les pseudo-instructions smw qui permet de réserver un mot mémoire en lui donnant une valeur, et rmw qui réserve un certain nombre de mots mémoire :
@compteur smw 0 % réserve un mot mémoire initialisé à 0 @tableau rmw 10 % réserve 10 mots mémoire pour un tableau
L'assembleur reconnaît également les noms symboliques sp (Stack Pointer) pour r6 et lr (Link Register) pour r7. Il accepte aussi les instructions push et pop qu'il émule en générant le code pour empiler la valeur d'un registre ou dépiler une valeur dans un registre.
push r2 % incrémente le pointeur de pile et range la valeur de r2 au sommet de la pile pop r5 % range dans r5 la valeur située au sommet de la pile et décrément le pointeur de pile
Format des instructions
| instruction | code | imm | rx | ry | rz | |||
|---|---|---|---|---|---|---|---|---|
| 4 bits | 1 bit | 3 bits | 3 bits | 3 bits | 2 bits | |||
| ldr rx,[ry] | 0000 | 0 | rx | ry | ||||
| ldr rx,adresse | 0000 | 1 | rx | |||||
| adresse | ||||||||
| str rz,[ry] | 0001 | 0 | ry | rz | ||||
| str rz,adresse | 0001 | 1 | rz | |||||
| adresse | ||||||||
| mov rx,ry | 0010 | 0 | rx | ry | ||||
| mov rx,#val | 0010 | 1 | rx | |||||
| val | ||||||||
| add rx,ry,rz | 0011 | 0 | rx | ry | rz | |||
| add rx,ry,#val | 0011 | 1 | rx | ry | ||||
| val | ||||||||
| sub rx,ry,rz | 0100 | 0 | rx | ry | rz | |||
| sub rx,ry,#val | 0100 | 1 | rx | ry | ||||
| val | ||||||||
| cmp ry,rz | 0101 | 0 | ry | rz | ||||
| cmp ry,#val | 0101 | 1 | ry | |||||
| val | ||||||||
| beq rz | 0110 | 0 | rz | |||||
| beq adresse | 0110 | 1 | ||||||
| adresse | ||||||||
| blt rz | 0111 | 0 | rz | |||||
| blt adresse | 0111 | 1 | ||||||
| adresse | ||||||||
| b rz | 1000 | 0 | rz | |||||
| b adresse | 1000 | 1 | ||||||
| adresse | ||||||||
Chemin de données
Logisim
Vous trouverez ci-dessous les versions de Logisim pour :
- Mac OS
- Logisim-mac-Java.zip, décompressez l'archive et placez l'application Logisim où vous voulez, par exemple dans le dossier Applications de votre Mac.
- Linux
- logisim-linux.tgz, décompressez l'archive, placez le dossier Logisim là où vous le souhaitez, puis, dans un terminal, placez vous dans ce dossier et exécutez la commande
./install.sh. Il suffit ensuite de double-cliquer sur le fichier Logisim pour lancer l'application. - Windows
- logisim-windows.exe