1 Présentation

Licence ST mention math´ ematiques-informatique
Informatique / MIP
Architecture des ordinateurs
Projet : une JVM cˆabl´ee (Partie I)
Universit´e de Provence
Ann´ee 2008-2009
1 Pr´esentation
Il existe deux fa¸cons d’ex´ecuter un programme ´ecrit dans un langage de haut niveau :
– traduire le programme de haut niveau dans un programme en langage machine, que le
processeur sait ex´ecuter directement ; on parle alors de compilation (gcc est un compilateur
pour le langage C).
– un programme ex´ecute le programme de haut niveau en traduisant `a la vol´ee ce dernier dans
un langage de bas niveau et en ex´ecutant cette traduction ; on parle alors d’interpr´etation
(php est une langage interpr´et´e).
Java a adopt´e une solution mixte : un programme Java est compil´e `a l’aide de la commande
javac vers un fichier de ”bas niveau” ind´ependant de toute architecture mat´eriel, un fichier .class.
Ce fichier .class est ensuite interpr´et´e en utilisant la commande java. Cet interpr´eteur java est
bas´e sur une mod`ele appel´e machine virtuelle java (Java Virtual Machine - JVM). Cette JVM est
bien sˆur logiciel.
L’objectif de ce projet est de faire une r´ealisation ”cˆabl´ee” de cette JVM. Cependant, pour que
cela reste r´ealiste, nous n’allons consid´erer qu’un fragment de Java et qu’une version simplifi´ee des
des fichiers .class.
1.1 Fichiers .class, bytecode java et JVM
Fichiers .class Les fichiers .class sont des fichiers binaires qui contiennent une version com-
pil´e des fichiers .java. Le langage ”machine” utilis´e dans les fichiers .class est ce qui est com-
mun´ement appel´e le bytecode java. Ce bytecode est le ”langage machine” de la JVM mais c’est
un ”langage machine” orient´e objet.
La structure des fichiers .class est quelque peu complexe et ne nous int´eressera pas, nous
n’allons donc pas la d´ecrire. Cependant, il est int´eressant de voir ce qu’est ce fichier dans une
forme plus lisible pour un ˆetre humain. De mˆeme qu’un programme assembleur est une forme
lisible d’un programme en langage machine, on peut obtenir une version ”lisible” d’un fichier
.class en utilisant sur ce fichier .class la commande javap -c. On peut voir `a la figure 1 un
programme Java `a gauche et `a droite le contenu du fichier .class correspondant (en version
”lisible”).
Bytecode java Nous d´etaillerons plus tard ce qu’est le programme de droite et chacune de ses
instructions (disons simplement que iadd sert `a faire une addition de deux entiers).
Une instruction de la machine virtuelle Java consiste en un opcode sur 1 byte (1 octet) sp´ecifiant
l’op´eration `a effectuer, suivie par z´ero ou plusieurs op´erandes servant d’arguments ou de donn´ees
qui seront utilis´es par l’op´eration. Plusieurs instructions n’ont pas d’op´erande et consiste donc
simplement en un opcode.
Concernant les types manipul´es par les programmes bytecode, ils correspondent essentiellement
au types manipul´es par Java, `a savoir les objets, les tableaux et les types primitifs ; ces types
primitifs sont notamment byte (8 octets), short (16 octets) , int (32 octets), long (64 octets)
pour les entiers ainsi que float (32 octets), double (64 octets) pour les flottants.
Afin de simplifier le probl`eme, nous n’allons consid´erer que le type primitif byte et donc toutes
nos donn´ees seront des entiers cod´ees sur 8 bits en compl´ement `a 2.
JVM La JVM (qui se lance par la commande java) est le programme qui charge (en m´emoire)
et qui ex´ecute le programme contenu dans un fichier .class. L’´el´ement le plus important de la

class essai {
static void main(){
int i ;
int s=0 ;
for (i=0 ;i<10 ;i++)
s = s + i ;
}}
class essai extends java.lang.Object{
static void main() ;
Code :
0 : iconst 0
1 : istore 1
2 : iconst 0
3 : istore 0
4 : iload 0
5 : bipush 10
7 : if icmpge 20
10 : iload 1
11 : iload 0
12 : iadd
13 : istore 1
14 : iinc 0, 1
17 : goto 4
20 : return
}
Fig. 1 – programme Java et son bytecode
JVM est une pile. C’est ce dispositif qui est utilis´e pour r´ecup´erer les op´erandes des instructions
et y placer les r´esultats. Par exemple, l’instruction iadd prendra deux entiers en sommet de pile,
en fera la somme et empilera le r´esultat. Outre la pile, la JVM utilise aussi une m´emoire classique
pour y mettre notamment les variables locales (des m´ethodes). Cette m´emoire contient aussi les
objets cr´ees mais ceci ne nous concerne pas car nos programmes ne contiendront pas d’objet.
2 Architecture de la machine cˆabl´ee
2.1 Description
Vous trouverez `a la figure 2 l’architecture g´en´erale de la JVM cˆabl´ee. Celle-ci est incompl`ete
mais permet de r´ealiser nombre des instructions que nous allons consid´erer pour notre JVM.
Nous allons d´ecrire ici un `a un ses ´el´ements contituants et nous verrons dans la section suivante
la r´ealisation de ces ´el´ements :
– Contrˆoleur : c’est le coeur du dispositif mais nous allons garder cette partie pour la fin du
travail
– M´emoire programme : cette m´emoire contient le programme bytecode `a ex´ecuter.
– M´emoire variable : cette m´emoire contient les variables locales du programme au cours de
son ex´ecution.
– Registre d’instruction (RI) : ce registre 8 bits contient l’instruction/le bytecode en cours
d’ex´ecution.
– Compteur programme (PC) : ce registre 16 bits contient l’adresse du bytecode en cours
d’ex´ecution.
– VarNumReg : ce registre 8 bits contient le num´ero de la variable dans lequel se fera la lecture
ou l’´ecriture.
– ALU : c’est une unit´e arithm´etique et logique 8 bits.
– X,Y : ce sont deux registres de 8 bits servant de registres d’entr´ee `a l’ALU.
– Pile : ce dispositif est de hauteur 8 et de largeur 8, c’est-`a-dire qu’elle peut contenir 8 mots
de 8 bits.
2

ALU
X Y
Xin Yin
ALUop
Push
Pop
Controleur
MUX
Pile
MUX
RI
Memoire Programme
PC
+1
Memoire variable
U
M
X
MPread MPwrite
MVwriteMVread
VarNum
VarNumReg
PCinH PCinL
VarNumRegin
SrcPushin
DataDest
RIin
16
8
8
16
8
8
PCin
Fig. 2 – Architecture de la JVM
3

2.2 R´ealisation des ´el´ements
Bien que non pr´esent `a la figure 2, tous les ´el´ements de m´emorisation de notre JVM ainsi que
son controleur seront synchronis´es par une horloge globale.
Pour la plupart des ´el´ements dont nous venons de parler, nous allons utiliser les ´el´ements de
m´emoire pr´ed´efinis dans tkgate.
Les registres 8 et 16 bits seront des registres de tkgate tandis que la m´emoire programme et la
m´emoire variable seront respectivement une ROM et une RAM, ´el´ements existants dans tkgate.
Les registres 8 bits VarNumReg, RI, X et Y sont charg´es par la valeur pr´esente sur leur bus
d’entr´ee 8 bits lorsque leur ligne de contrˆole, `a savoir respectivement, VarNumRegin,RIin,Xin et
Yin, est `a 1.
Il est `a noter que le registre 16 bits PC poss`ede deux bus d’entr´ee de donn´ees, un bus 16 bits et
un bus 8 bits. Lorsque le signal d’entr´ee PCin est `a 1 alors la valeur pr´esente sur le bus 16 bits est
charg´ee dans le registre. Les deux autres signaux concernent l’entr´ee 8 bits du registre : lorsque
le signal PCinL est `a 1 alors les 8 bits de l’entr´ee sont charg´es dans la partie basse du registre PC
tandis que si PCinH est `a 1 alors ces 8 bits sont charg´es en partie haute.
Les 3 ´el´ements importants `a r´ealiser sont donc l’ALU, la pile et le contrˆoleur.
La r´ealisation du contrˆoleur sera l’objet de la partie II de ce projet tandis que l’ALU ne sera
qu’une extension de celle r´ealis´ee en TP 1. Les entr´ees de contrˆole ALUop d´etermine la fonction
que doit r´ealiser l’ALU (addition, soustraction, et logique, ...).
Notre pile poss`ede une entr´ee de donn´ee (servant `a entrer la donn´ee `a empiler) et une sortie de
donn´ee (servant `a r´ecup´erer la donn´ee empil´ee en sommet de pile). Elle poss`ede de plus 2 entr´ees
de contrˆole :
– l’entr´ee Push mise `a 1 fait que la valeur sur la ligne d’entr´ee de donn´ee est empil´ee.
– l’entr´ee Pop mise `a 1 fait que la valeur sur le sommet de la pile est d´epil´ee.
Il est `a noter que la valeur de sortie est toujours la valeur au sommet de la pile.
1Vous pourrez la compl´eter `a l’aide du descriptif complet des instructions de la JVM donn´ee en partie II.
4