Réf.

: H1588 V2

Machine virtuelle Java

Date de publication :
10 août 2013 (JVM)

Cet article est issu de : Technologies de l'information | Technologies logicielles

Architectures des systèmes

par Jean-Michel DOUIN

Mots-clés Résumé Le succès de Java l'a promu langage de programmation sur internet. Cet article
architecture présente une architecture synthétique et idéale de la machine virtuelle, ainsi que le
format du fichier compilé et un sous-ensemble du jeu d'instructions. Les instructions de la
machine sont regroupées par famille et leur description est associée aux codes sources
Java les ayant engendrées. Les avantages de cette solution sont connus et multiples,
l’inconvénient majeur restant le surcoût en temps d’exécution.

Keywords Abstract Due to its success Java has become the programming language of the Internet.
architecture This article presents a synthetic and ideal architecture of the virtual machine, together
with the format of the compiled file and a subset of the instruction set. The machine
instructions are grouped by family and their description is associated with the Java source
codes that have generated them. Although the advantages of this solution are known and
numerous, the major drawback remains the additional cost in execution time.

Pour toute question :

Service Relation clientèle
Techniques de l’Ingénieur
Immeuble Pleyad 1 Document téléchargé le : 21/11/2025
39, boulevard Ornano
93288 Saint-Denis Cedex Pour le compte : 7200031372 - nantes universite // [Link]

Par mail :
[Link]@[Link]
Par téléphone :
00 33 (0)1 53 35 20 20 © Techniques de l'Ingénieur | Tous droits réservés
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

Machine virtuelle Java (JVM)

par Jean-Michel DOUIN

Ingénieur et docteur du CNAM
Enseignant/chercheur au CNAM

1. Contexte .................................................................................................... H 1 588v2 - 2

1.1 Langage Java .............................................................................................. — 2
1.2 Structures syntaxiques essentielles .......................................................... — 3
1.3 Modèle de compilation, indépendance de la plate-forme....................... — 3
1.4 Applet et application................................................................................... — 4
2. Architecture de la machine.................................................................. — 4
2.1 Types de données....................................................................................... — 4
2.2 Exécutif ou processeur virtuel ................................................................... — 4
2.3 Chargeur de classes.................................................................................... — 6
2.4 Mémoire d’objets et ramasse-miettes ...................................................... — 6
2.5 Java Native Interface JNI ........................................................................... — 7
3. Classes Java ............................................................................................. — 8
3.1 Format du fichier compilé .......................................................................... — 8
3.2 Compatibilité binaire .................................................................................. — 8
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

3.3 Décompilateur............................................................................................. — 8
3.4 Chargement et édition des liens................................................................ — 9
3.5 Vérification du fichier compilé................................................................... — 9
4. Jeu d’instructions/source Java ........................................................... — 9
4.1 Exemples ..................................................................................................... — 9
4.2 Notation et format des instructions .......................................................... — 10
4.3 Évaluation d’expressions arithmétiques................................................... — 12
4.4 Opérations de manipulation de la pile...................................................... — 12
4.5 Variables locales ......................................................................................... — 12
4.6 Conversions implicites et explicites .......................................................... — 13
4.7 Expressions booléennes ............................................................................ — 13
4.8 Instructions de contrôles............................................................................ — 14
4.9 Instructions pour la sélection (switch/case) — 14
4.10 Variables de classes.................................................................................... — 14
4.11 Appel de méthodes de classes .................................................................. — 15
4.12 Allocation des objets, variables d’instance, appel du constructeur ....... — 16
4.13 Tableaux ...................................................................................................... — 17
4.14 Héritage, appel de méthode d’instance et liaison dynamique................ — 17
4.15 Interface ....................................................................................................... — 17
4.16 Test d’appartenance et conversion de type.............................................. — 17
4.17 Exceptions ................................................................................................... — 19
4.18 Threads ........................................................................................................ — 19
4.19 Optimisations .............................................................................................. — 19
5. Conclusion ................................................................................................ — 22
Pour en savoir plus ........................................................................................... Doc. H 1 588v2

a popularité du web a promu Java comme langage de programmation sur

L Internet. Ce succès est venu dans un premier temps de l’intégration d’une
machine virtuelle Java au sein de tout navigateur. Le langage Java s’est
imposé peu à peu dans le monde académique et également dans l’industrie. La
machine virtuelle Java JVM (Java Virtual Machine) est présente sur de

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 1

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

nombreuses architectures comme des serveurs d’applications, des caisses

enregistreuses, des téléphones mobiles ou encore sur les cartes SIM. La
machine virtuelle a peu évolué en un plus de quinze années, ce qui est remar-
quable dans le monde de l’informatique. Le code intermédiaire engendré par la
compilation d’un code source Java est chargé et exécuté par la machine vir-
tuelle. L’exécution du même code intermédiaire quelle que soit la plate-forme
offre aux développeurs en Java une large diffusion de leurs programmes. La
machine virtuelle et les librairies associées garantissent une exécution du code
Java indépendante du système d’exploitation et d’une architecture matérielle.
Les composantes de la machine virtuelle Java et le format du code intermé-
diaire permettent l’accès aux objets distants et le déploiement du code à
travers le réseau. Ces caractéristiques sont essentielles dans un environnement
distribué et contribuent au succès actuel du langage et de la machine virtuelle.
La machine Java est un programme interprétant les instructions transmises
par le réseau ou les instructions extraites d’un fichier local.
Les avantages de cette solution éprouvée sont connus et multiples :
– le code est portable quelle que soit la plate-forme, car il suffit que chaque
plate-forme possède un interpréteur de ce code et les librairies d’accès aux res-
sources de la machine hôte ;
– le code chargé peut être vérifié au chargement. La vérification du code est
facilitée et primordiale dans un environnement ouvert comme Internet ;
– le code est en général plus compact. L’architecture de la machine Java est
de type machine à pile, les opérandes des instructions devenues implicites
engendrent une taille de code moins importante qu’une machine traditionnelle
à registres.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

L’inconvénient majeur réside dans le surcoût en temps d’exécution dû à cette

couche logicielle supplémentaire.
L’architecture de la machine est liée aux concepts de la programmation en
langage orienté objet, mais la machine reste indépendante du langage de pro-
grammation. Le seul type en entrée admis par la machine est le type du fichier
compilé. Le format de ce fichier a permis plusieurs extensions conséquentes
du langage Java sans aucune modification de la machine.

1. Contexte type hérité super-type, alors un objet du type est-un un objet du

super-type. Chaque type de données est regroupé au sein d’une
structure syntaxique appelée classe. Chaque classe possède des
attributs ou champs d’instance et des propriétés ou méthodes. Les
1.1 Langage Java classes appartiennent à un arbre d’héritage. Un objet est une
instance d’une classe.

Java est simple. Sa syntaxe est basée sur les langages C et C++.
La machine Java est une machine langage : les choix L’absence de pointeurs améliore nettement la lisibilité des codes
d’architecture, le jeu d’instructions reflètent les concepts du sources. Un ramasse-miettes dispense le programmeur de la
langage Java. Certaines caractéristiques du langage doivent gestion de la mémoire.
être rappelées afin de mieux appréhender la machine virtuelle.
Java est fortement typé. L’affectation entre objets doit être
Nota : cette présentation simplifiée des concepts est extraite de [1] et [H 3 088]. effectuée entre deux objets liés entre eux par la relation d’héritage.
Les changements de type explicites sont vérifiés à l’exécution. Une
Java est un langage de programmation orienté objet. Cette exception est levée en cas d’erreur.
technique de programmation oriente le développement d’une
application par les types de données utilisés. Les noms des types Java permet la programmation distribuée. L’accès aux objets
sont en général extraits du contexte du projet. Une classification distants ainsi que la migration de code à travers Internet sont
de ces types de données analogue à la langue naturelle par la intégrés. L’introspection d’un objet fait partie du langage et permet
relation est-un est effectuée. L’héritage en programmation orientée entre autres de déclencher des méthodes d’un objet ayant migré
objet propose une implémentation de cette relation est-un. Un type d’un poste à l’autre. La génération dynamique de mandataire utili-
de données peut hériter d’un autre type, il possède alors en son sant l’introspection permet de simplifier les accès distants pour le
nom les attributs et les propriétés du type hérité. Si on appelle le développeur.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 − 2 est strictement interdite. − © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

La sécurité est essentielle dans un environnement distribué. La La classe constatée appartient à l’arbre d’héritage établi à la
machine Java dispose d’un outil de vérification des données et du compilation. En Java, la racine de toute classe est la classe
code transmis par le réseau. Les navigateurs possèdent des [Link].
contraintes de sécurité supplémentaires. Des vérifications sont
également faites à l’exécution. ■ Exceptions et clause finally
Un mécanisme d’exceptions est présent en Java. Il est utilisé
Java propose la notion de processus léger, ou thread, et un
afin de gérer un traitement anormal en cours d’exécution. Le bloc
mécanisme de protection d’accès aux ressources dans un environ-
try/catch permet de filtrer l’exception et éventuellement de la
nement concurrent, ainsi que la notion d’événements liée à l’état
propager vers l’appelant. La clause finally regroupe un bloc
d’une ressource.
d’instructions qui est toujours exécuté après à la sortie du bloc
try/catch auquel cette clause est rattachée.

1.2 Structures syntaxiques essentielles ■ Variables et blocs statiques

La notion de variable statique est analogue à celle de variable
■ Variables locales et instructions « impératives » globale dans d’autres langages de programmation : une variable
statique et publique, est accessible par toute classe et n’existe
Java est un langage à structure de blocs ; les variables locales
qu’en un seul exemplaire, quel que soit le nombre d’instances
au bloc sont accessibles, pendant l’exécution, à l’entrée dans
créées. Les variables statiques sont initialisées aux valeurs par
celui-ci, et disparaissent en fin de bloc. Cette notion de variables
défaut. Cette initialisation est effectuée une seule fois au charge-
locales trouve une implémentation traditionnelle par une pile de
ment de la classe. Le bloc statique implicite ou explicite d’une
variables dont l’évolution est liée aux appels de méthodes
classe permet d’exécuter une séquence de code au moment du
successifs. Les instructions engendrées pour les structures de
chargement de la classe, les instructions contenues sont générale-
sélection et d’itération sont analogues à la compilation de ces
ment des affectations de variables de classe.
structures pour un autre langage.
■ Moniteur de Hoare
■ Variables d’instance, héritage
Le langage Java propose ce mécanisme d’accès et de synchroni-
Un objet est instance d’une classe et chaque allocation d’objet sation aux ressources pour un environnement concurrent : toute
effectuée par l’opérateur new demande au gestionnaire de méthode d’une classe préfixée par le mot-clé synchronized garantit
mémoire une zone dont la taille est égale au cumul des tailles de un usage en exclusion mutuelle d’un objet instance de cette
toutes les variables d’instances héritées. La référence retournée classe. Si un autre thread effectue l’appel d’une méthode
par le gestionnaire de mémoire permet ensuite l’accès aux « synchronisée », alors ce thread est bloqué et mis en attente.
différents champs d’instance. Les variables sont initialisées par Chaque instance possède en interne une file des processus
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

défaut. Le constructeur de la classe correspondante ainsi que tous bloqués. Un mécanisme d’attente et de notification, d’un
les constructeurs des classes héritées sont déclenchés à chaque événement lié à la valeur d’une ressource partagée, est hérité de la
allocation d’un objet. classe Object, mécanisme appelé variable condition.

■ Méthodes, héritage
Les méthodes de la classe fournissent le comportement des 1.3 Modèle de compilation,
instances de cette classe. La classe effective d’une instance ne indépendance de la plate-forme
peut être déterminée qu’à l’exécution ; cette classe, que l’on
nomme classe constatée afin de la distinguer de la classe déclarée Avant d’exécuter une application Java, le code source Java doit
dans la source de l’instance, reflète le comportement attendu par être compilé afin de produire un fichier objet reconnu par la
le programmeur. En Java, la sélection du comportement d’une machine virtuelle Java. Ce fichier est ensuite chargé depuis le
instance en fonction de la classe constatée est mise en œuvre par réseau ou localement. Toute plate-forme possédant une machine
défaut. Ce mécanisme de sélection est appelé liaison dynamique. virtuelle Java peut exécuter ce code (figure 1).

public class Point {

Source Java -
[Link] } 1
Compilation

Fichier compilé
[Link] 1100 1010 1111 1110 1011 1010 1011 1110 0000 0011 0001 1101...

Lecture du fichier
locale ou distante

Machine Machine Machine

virtuelle virtuelle virtuelle
Java Java Java
SUN Mac PC

PC/ Mac PC 2
Windows MacOS Linux Interprétation

Figure 1 – Compilation et interprétation d’une classe

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 3

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

1.4 Applet et application Tableau 1 – Types de la machine

Les applets sont des instances d’une classe standard Type Représentation (1)
[Link] ou [Link] ; les instances de cette byte 8 bits en complément à 2 (– 27 à 27 – 1)
classe sont utilisées par les navigateurs munis d’une machine
virtuelle. La classe chargée doit s’inscrire dans le contexte de sécu- short 16 bits en complément à 2 (– 215 à 215 – 1)
rité induit par l’usage d’un navigateur sur un poste banalisé. int 32 bits en complément à 2 (– 231 à 231 – 1)
Une application Java s’exécute sur la machine hôte de façon long 64 bits en complément à 2 (– 263 à 263 – 1)
autonome. La machine virtuelle est en général accessible comme
n’importe quel exécutable. Le programme débute par les instruc- char 16 bits format Unicode (0 à 216 – 1)
tions contenues dans la méthode statique main. La technologie float 32 bits IEEE 754, simple précision
JavaWebStart garantit au client l’usage de la dernière version
double 64 bits IEEE 754, double précision
d’une application, celle-ci devant être signée avant d’être mise à
disposition. reference Un mot, la référence d’un objet en mémoire ou null
La distinction applet/application est sans effet sur la machine address Un mot, l’adresse d’une instruction
virtuelle. Depuis un navigateur seul, le chargeur de classes est (1) Quelle que soit la plate-forme.
concerné par des contraintes de sécurité supplémentaires ; elles
concernent généralement les accès aux ressources locales de la
machine hôte comme la configuration et les fichiers locaux.
2.1 Types de données

2. Architecture de la machine Le langage Java distingue les types primitifs et un type

unique référence (reference ) pour les instances de classe
(tableau 1). Cette distinction se retrouve dans la machine par le
format des données utilisées et les instructions associées.
Les principales composantes de la machine Java (figure 2)
sont le chargeur de classes, la mémoire des objets, les Tous les types primitifs du langage Java, à l’exception du type
librairies natives et l’exécutif ou processeur virtuel. Cet boolean, sont des types primitifs de la machine virtuelle. Les types
exécutif est lui-même composé de l’interpréteur des instruc- numériques sont discrets ou flottants. Les types discrets sont byte,
tions, de la zone du code et des données de classe et de la short, int, long et char. Les types flottants sont les types float et
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

zone des environnements. L’implémentation de ces double. Le type Java boolean est représenté dans la machine par
composantes peut être réalisée par du matériel ou du logiciel. un entier de type int ou byte, l’entier 0 est associé à la valeur false,
L’architecture développée ici complète l’architecture de la une valeur différente de 0 correspond à la valeur true.
machine virtuelle proposée par Oracle [2]. Les valeurs de type reference sont inaccessibles au program-
meur, elles représentent les adresses en mémoire des objets. En
cours d’exécution, ces adresses sont obtenues à l’allocation des
objets. L’objet alloué est soit une instance de classe, soit un tableau.
Également invisible au programmeur, le type address
Réseau, Internet implémente une adresse dans le code de la méthode en cours. Les
Machine hôte,
valeurs de ce type sont utilisées lors de l’exécution du bloc de
Machine locale, système gestion des exceptions avec la clause finally.
disque, PROM... d’exploitation L’unité de base de la mémoire de la machine virtuelle est le mot.
Un mot doit être choisi afin qu’il puisse contenir une variable de
type Java byte, short, int, long ou char. Une implémentation d’un
mot en 32 bits nécessite deux mots pour les types long et double.
L’implémentation du mot correspond en général à la taille d’une
adresse de la machine hôte.
Chargeur Mémoire Librairies natives
dynamique d’objet et – fichiers
de classe ramasse-miettes – thread 2.2 Exécutif ou processeur virtuel
L’unité d’exécution est constituée d’une table contenant les
classes après chargement, de l’interpréteur des instructions et de
la zone des environnements.
Chaque classe contient le code des méthodes et leurs données,
ainsi que les variables statiques de la classe.
L’interpréteur d’instructions exécute les instructions de la
méthode en cours, avec l’environnement du processus léger ou
thread actif.
Exécutif
Chaque environnement contient :
Code et Interpréteur Environnements – une pile d’exécution qui reflète l’enchaînement des appels des
données des et piles méthodes ;
des classes instructions d’exécution – une pile d’évaluation qui est utilisée par l’interpréteur
d’instructions à la suite d’opérations arithmétiques ou logiques et
également lors du passage des paramètres ;
– une zone de contexte qui mémorise l’état de la machine et qui
contient en général les registres et toutes les informations liées au
Figure 2 – Système Java minimal et idéal thread actif.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 4 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

L’interpréteur utilise également une pile d’exécution et un

environnement pour les instructions associées aux appels de
méthodes.
cl
Code méthode 1 Chaque environnement possède sa pile d’évaluation et sa pile
me d’exécution.
Code méthode 2
pc { iload, dup...} Nota : le paragraphe 4 détaille le jeu d’instructions.
Constantes référencées
par le code
2.2.3 Environnements et piles d’exécution
gvars
Variables statiques
La création d’un thread Java engendre la création d’un
environnement. Chaque environnement possède une pile dans
laquelle sont placés les segments d’activation des méthodes
appelées (figure 4). Un segment d’activation contient les variables
Table des classes locales et l’adresse de retour après l’exécution de la méthode.
L’environnement du thread contient également sa pile d’évaluation
Figure 3 – Code et données des classes et la zone de sauvegarde de l’état de la machine : son contexte.

■ Pile des blocs ou segments d’activation

L’état de la machine est sauvegardé à chaque nouvelle
attribution du processeur à un autre thread, attribution décidée par L’appel d’une méthode engendre la création d’un segment
l’ordonnanceur ; le contexte du thread sélectionné devient l’état de d’activation placé au sommet de la pile d’exécution. Ce segment
la machine. courant est référencé par le registre frame ; il contient les informa-
tions nécessaires au retour vers la méthode appelante ainsi que
2.2.1 Code et données des classes les variables locales de la méthode appelée. La première variable
locale est indicée par le registre vars. Les paramètres font partie
Une table recense les classes de l’application. Cette table est enri- des variables locales et sont recopiés de la pile d’évaluation par la
chie dynamiquement par le chargeur de classe. À un indice dans machine avant l’exécution de la méthode. Ces paramètres ont été
cette table est associée une classe courante par le registre cl. Chaque préalablement empilés par la méthode appelante.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

classe contient le code de ses méthodes, les constantes référencées

par les instructions et la zone des variables statiques. L’interpréteur
Exemple : l’état de la pile de la figure 5 correspond à l’appel de la
exécute le code d’une méthode, référencée par le registre me
méthode 1 par la méthode 0, puis de l’appel de la méthode 2 par la
(figure 3). L’instruction en cours est désignée par le compteur ordi-
méthode 1. Le bloc d’activation de la méthode 2 contient l’adresse de
nal, le registre pc. La zone des variables statiques ou globales est
retour vers la méthode appelante et possède deux variables locales i
accessible par le registre gvars. Le bloc statique d’une classe est exé-
et j. Elle est en cours d’exécution.
cuté une seule fois au chargement de celle-ci ; ce code en interne est
regroupé au sein de la méthode nommée <clinit>. Le chargement
des classes est dynamique ; en conséquence, les structures internes
d’une classe pourraient se trouver dans une zone mémoire dans
laquelle les instances inutilisées sont gérées par un ramasse-miettes. vars
Pile des Pile des
frame segments segments
2.2.2 Interpréteur des instructions d’activation d’activation
L’interpréteur exécute l’instruction référencée par le registre pc.
Une instruction de la machine consiste en un octet spécifiant le code Contexte Contexte Contexte
opération, suivie de zéro ou plusieurs octets de données. L’algo-
rithme général d’un interpréteur est résumé par l’itération suivante. optop Pile Pile Pile
d’évaluation d’évaluation d’évaluation

Tant que la fin du programme n’est pas rencontrée faire Environnement Theard 2 Theard 3
du theard 1 (actif)
Lecture d’une instruction, instruction = code [pc]
Environement par theard
En fonction du code opération de l’instruction
Lire éventuellement les opérandes depuis le code ou la pile
Figure 4 – Environnements et piles d’exécution
Effectuer les actions correspondantes,
Affecter le compteur ordinal en conséquence, pc = pc + n
Fin tant que

L’interpréteur de la machine virtuelle Java utilise une pile j

vars
d’évaluation pour les instructions engendrées à la compilation i
d’expressions.
frame Retour vers la méthode 1
Exemple
Segment d’activation de la méthode 1
L’expression z = x + y produit la séquence d’opérations suivante :
empiler (x), empiler (y), additionner, ranger le sommet de pile en z. Segment d’activation de la méthode 0
L’opération additionner retire les opérandes placés préalablement sur
la pile. Figure 5 – Pile des segments d’activation

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 5

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

optop
optop optop
y
optop
x x x+y
empiler (x) empiler (y) additionner

Figure 6 – Pile d’évaluation

pc Mémoire optop
me de code Interpréteur Environnements
frame
cl et données des et piles
vars
gvars des classes instructions d’exécution
pe

Figure 7 – Registres, chemins de contrôle et données de l’exécutif

■ Pile d’évaluation depuis le réseau, charge les classes héritées, réalise l’édition des
Cette pile est utilisée lors de l’évaluation des expressions liens et vérifie le contenu sémantique et syntaxique des fichiers
arithmétiques ou logiques. Les valeurs retournées par les chargés. L’exécution des blocs statiques des classes chargées est
différentes instructions sont placées sur la pile. Les paramètres effectuée et enfin l’exécution des constructeurs.
transmis aux méthodes utilisent également la pile d’évaluation. Le Nota : le format du fichier et le chargeur de classe sont détaillés au paragraphe 3.
sommet de pile est référencé par le registre optop.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

Exemple : la figure 6 décrit le calcul de l’expression x + y, soit la 2.4 Mémoire d’objets et ramasse-miettes
séquence des pseudo-instructions {empiler (x) ; empiler (y) ;
additionner}. Un objet est créé en Java par l’opérateur new. Une zone de la
taille nécessaire est réservée en mémoire des objets ; une
2.2.4 Registres, état de la machine référence sur cette zone est retournée, cette référence étant
affectée à la variable du programme.
Analogues aux registres d’un microprocesseur, les registres de La taille de l’objet est le cumul des tailles des données
la machine Java représentent l’état de la machine en cours d’instance de cette classe et des classes héritées ; d’autres
d’exécution (figure 7). Ils sont lus et modifiés par l’interpréteur informations sont ajoutées, comme la référence sur la classe
d’instructions. Les registres suivants sont issus de la documenta- d’appartenance de l’objet.
tion d’Oracle :
La structure interne d’une classe doit être compatible avec la
– pc : le compteur ordinal, adresse de l’instruction en cours ;
définition en Java de la classe [Link]. Le programmeur
– optop : un pointeur sur le sommet de la pile d’évaluation ; Java peut demander la classe constatée d’une instance. La
– frame : un pointeur sur le segment d’activation de la méthode méthode getClass( ) de la classe [Link] dont la signature
en cours ; est public final Class getClass( ) ; est exécutée, la référence retour-
– vars : un pointeur sur la première variable locale de la méthode
née étant de type Class. Toutes les informations de cette classe
en cours.
deviennent accessibles au programmeur Java via cette référence.
D’autres registres caractérisent l’état de la machine :
– un registre dénotant l’environnement courant associé au Exemple : la figure 8 illustre deux créations d’instance (obj et p) et
processus (pe) ; l’obtention de la classe constatée (p) ; obj reçoit p par affectation ; le
– un pointeur sur la classe courante (cl) ; type constaté de obj devient Point ; la structure précédemment
– la référence de la méthode courante (me) ; référencée devient récupérable par le ramasse-miettes (figure 8b ).
– un pointeur sur la zone de variables de la classe (gvar).
Ces registres, présents dans certaines implémentations, sont liés Le ramasse-miettes libère les zones qui ne sont plus référencées
aux choix d’implémentations de la machine virtuelle. par les variables du programme. Ces zones compactées deviennent
Les structures internes présentées sont celles d’une JVM idéale, libres pour une nouvelle allocation. Le déclenchement du
telle qu’elle est décrite dans les documents référents. La réalité des ramasse-miettes intervient lorsque la mémoire des objets est pleine
machines Java est tout autre et plus complexe, due notamment ou de manière incrémentale, selon l’algorithme du récupérateur de
aux optimisations effectuées sur ces machines. mémoire. Un récupérateur séquentiel interrompt le programme uti-
lisateur de la durée nécessaire au compactage. Un récupérateur
concurrent agit en même temps que l’exécution du programme uti-
lisateur. Le déclenchement intervient en temps partagé ou en paral-
2.3 Chargeur de classes lèle sur un coprocesseur chargé de la mémoire des objets.
Les programmes Java sont structurés en classes. Une classe Il existe plusieurs algorithmes de récupérateur de mémoire.
Java engendre un fichier compilé chargé dynamiquement au fur et Citons trois algorithmes classiques de ramasse-miettes avec des
à mesure des besoins. À la première création d’une instance d’une compteurs de référence (reference counting ), par marquage
classe, le chargeur de classes recherche le fichier localement ou (mark-and-sweep ) et par copie (stop and copy ).

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 6 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

Source Java

Classe
Champs d’instance de object
Object obj = new object (); [Link]

super

Classe
Point
Point p = new Point (); Champs d’instance de
[Link]
+ champs d’instance de
Point

class cl = [Link] ();

a deux objets et leurs structures référencées

Classe
Champs d’instance de object
[Link]

super

obj = p;
Classe
Champs d’instance de Point
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

[Link]
+ champs d’instance de
Point

b résultat d’une affectation polymorphique

Figure 8 – Mémoire d’objets et ramasse-miettes

■ Compteurs de référence 2.5 Java Native Interface JNI

Cette technique associe un compteur à chaque objet, initialisé à 1
lors de la création de l’objet. Le compteur s’incrémente à chaque nou-
velle référence sur cet objet et est décrémenté lorsque le bloc auquel JNI est une librairie permettant au programmeur Java
appartient la référence se termine. Tout objet dont le compteur est à 0 d’intégrer du code natif développé en C ou C++, et également
devient récupérable. Lorsqu’un objet est récupéré, ses objets référen- d’exécuter du code Java depuis une application en C ou C++.
cés ont leur compteur décrémenté. Cette technique ne permet pas de L’usage de cette librairie assure la portabilité des sources C
détecter les objets libres en cas de références mutuelles. quelle que soit la plate-forme si la machine virtuelle est
■ Marquage conforme aux spécifications demandées par JNI.
Cet algorithme procède en deux phases. Lors de la phase de
marquage, le récupérateur parcourt l’arbre des objets accessibles
L’appel de C depuis Java nécessite le chargement par le
en affectant le champ de marquage associé à chaque objet. Puis,
programme Java de la librairie native. En Java, les méthodes
dans la seconde phase dite de récupération, tous les objets non
natives sont préfixées par le mot-clé native, les méthodes en C cor-
marqués sont libérés.
respondantes respectent des conventions d’écriture. La machine
■ Copie virtuelle à l’occurrence de l’appel d’une méthode native effectue la
Le principe est de recopier les objets accessibles dans une autre recherche de la procédure C dans la librairie préalablement char-
zone mémoire. Lors de la recopie, les objets sont placés de façon gée et transfère à la fonction C appelée les paramètres depuis la
contiguë et le compactage des zones libres n’est plus nécessaire. pile d’évaluation. À la terminaison de la procédure C, la machine
Cette technique nécessite une indirection supplémentaire entre la virtuelle poursuit son exécution.
référence du programme utilisateur et l’adresse de l’objet alloué. Certaines librairies prédéfinies du paquetage [Link]
Le programmeur Java peut explicitement déclencher le nécessitent une implémentation native. Leurs fonctions dépendent
ramasse-miettes par l’appel de la méthode [Link]- de la machine hôte, respectent le standard d’écriture proposé par
time().gc( ). Lors de la récupération de l’espace mémoire d’un objet, JNI et sont liées aux entrées-sorties de texte, fichiers ou graphi-
la méthode finalize( ) de l’objet est déclenchée. À l’exécution de la que. Les implémentations de la gestion des processus et du choix
machine virtuelle, des options de la ligne de commande permet- d’ordonnancement peuvent être réalisées en appelant les fonc-
tent de choisir la stratégie du GC (Garbage – First Collector). tions du système d’exploitation de la machine hôte.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 7

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

L’appel de Java depuis C nécessite de disposer d’un ensemble Plusieurs champs sont de longueur variable, comme le champ
de primitives d’accès à la machine virtuelle. Ces primitives methods dont la taille, définie par method_count, correspond au
permettent de créer une machine virtuelle, de charger le code des nombre de méthodes de la classe Java. Le champ interfaces
classes, de créer des instances d’objets, d’accéder aux variables et recense les interfaces implémentées par cette classe.
aux méthodes. Ces fonctions utilisent des types de données
Nota : pour la définition de chaque champ, se reporter en [2].
compatibles ou confondus avec les types de la machine Java. Le
programmeur C peut également engendrer des threads, bloquer le
ramasse-miettes, adresser l’espace mémoire de la machine. Tou-
tes ces fonctions et les définitions de types font partie de l’implé- 3.2 Compatibilité binaire
mentation d’une machine virtuelle.
Aucun choix d’implantation n’est effectué lors de la génération
du fichier .class. Une variable d’instance est décrite par son nom et
non par un déplacement dans une zone mémoire. Une méthode
est désignée par son en-tête et sa signature en chaîne de caractè-
3. Classes Java res et non par une adresse de code.
Le choix de conserver une forme symbolique du fichier compilé
est la conséquence des exigences de compatibilité binaire de Java.
Cette compatibilité est préservée lors des changements de code
Chaque fichier contient un type Java (une classe, une inter- source Java décrits dans le chapitre 13 de [1], les modifications de
face ou une énumération). Un fichier est généré pour une code source les plus significatives sont :
classe interne, locale ou anonyme. Ce fichier contient le code et – l’ajout de nouveaux champs, méthodes ou constructeurs à une
toutes les données nécessaires à l’exécution des instructions classe ou à une interface ;
de la machine virtuelle. Ces données sont pour la plupart dans – le retrait de champs, méthodes ou constructeurs privés d’une
leur forme symbolique. Le format choisi du fichier permet de classe ou d’une interface ;
respecter les contraintes de compatibilité binaire et d’autoriser – le réordonnancement de champs, méthodes ou constructeurs
de futures extensions. Les principales étapes du chargeur de dans une classe existante ;
classes locales ou distantes sont également présentées. – l’ajout d’une nouvelle classe ou interface dans la hiérarchie
d’une classe.
Ce choix de forme symbolique induit :
3.1 Format du fichier compilé – la possibilité de décompilation d’un fichier .class ;
– la résolution des liens à la responsabilité du chargeur de classes.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

Le fichier compilé (ou fichier dont le suffixe est « .class »)

forme une suite d’octets.
3.3 Décompilateur

Deux octets lus forment un mot de 16 bits, l’octet de poids fort étant Le but d’un décompilateur Java est de convertir un fichier
en premier. Les mots de 32 et 64 bits sont construits de la même .class en un code source Java.
façon. Les noms de types u1, u2 et u4 choisis par SUN [2] représen-
tent respectivement les données sur un, deux et quatre octets. Les
composantes du fichier .class sont dans l’ordre d’apparition [magic, La forme symbolique du fichier compilé permet une telle
minor_version, major_version, constant_pool, access_flags, this_class, conversion. Plusieurs outils existent, Mocha [2] semble le plus
super_class, interface, fields, methods, attributes]. connu. L’objectif est avouable lorsqu’il s’agit de reverse-enginee-
ring, comme par exemple une mise en conformité des fichiers
Ces champs sont rassemblés dans une structure nommée compilés et des codes sources Java. L’objectif peut également être
ClassFile définie ci-dessous dans une syntaxe apparentée au inavouable : dans ce cas, les fichiers compilés peuvent être
langage Java. cryptés. Un tel fichier décompilé devient en principe illisible :
– les identificateurs de classes et de variables sont remplacés
par des numéros ;
structure ClassFile { – certains champs du fichier compilé sont supprimés ;
u4 magic; – tout est fait afin de décourager un éventuel lecteur d’un fichier
u2 minor_version; .class reconstitué.
u2 major_version; Les outils Crema ou Proguard permettent de crypter un fichier
u2 constant_pool_count; .class.
info constant_pool [constant_pool_count];
u2 access_flags; Exemple
u2 this_class; Classe Point : décompilation produite par l’utilitaire Mocha
u2 super_class; / * Decompiled by Mocha from [Link] */
u2 interfaces_count; / * Originally compiled from [Link] */
u2 interfaces [interfaces_count]; public synchronized class Point {
u2 fields_count; private static int compte = 0;
field_info fields [fields_count]; private int x; private int y;
u2 method_count; public Point () {this(0, 0); }
method_info methods [method_count]; public Point (int i, int j) {moveTo (i, j); compte=compte+1; }
u2 attributes_count; public int distOrigin () {return (int) [Link] ( (double) (x * x + y * y)); }
attribute_info attributes [attributes_count]; public void moveTo (int i, int j) {x = i ; y = j; }
} }

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 8 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

À l’exception des identificateurs des paramètres de méthodes et Passe 3 : cette étape assure la cohérence du code généré.
des commentaires, le code source décompilé est ici très proche du Chaque séquence de code de chaque méthode est vérifiée. Une
code source initial. analyse du flot d’instructions est effectuée. Les instructions et leurs
opérandes sont extraits du code. Le format de chaque instruction
extraite est validé. Toutes les adresses de sauts des instructions de
3.4 Chargement et édition des liens contrôles doivent être des adresses d’instructions. Toutes les
opérations sur la pile doivent être cohérentes : « dépiler un entier »
La machine Java charge dynamiquement les classes compilées, (istore) doit être précédé d’une opération de type « empiler une
réalise les éditions des liens et exécute les initialisations de la ou valeur de type entier » (iload ou instruction équivalente). Toutes
des classes chargées. les références au champ constant_pool sont vérifiées : l’opérande
Le processus de chargement consiste à rechercher le fichier de l’instruction ldc1 doit référencer un entier et l’opérande de
compilé et à créer une représentation interne de cette classe. Les l’instruction getfield doit indiquer une entrée appropriée. Chaque
classes héritées sont également chargées et les autres classes gestionnaire d’exceptions est validé : les adresses mentionnées
mentionnées dans ce fichier sont chargées au moment de leur sont valides en désignant une adresse d’instruction.
utilisation, au fur et à mesure, lors de la première création d’une Passe 4 : cette passe assure également la cohérence des instruc-
instance par exemple. La recherche du fichier est locale ou tions utilisant d’autres classes que la classe analysée. Une affecta-
distante. Le fichier peut être extrait d’une archive (zip, jar, cab ou tion d’une instance par un objet d’une classe dérivée est validée
autres). Le chargeur peut demander la compilation d’un code quand la classe désignée est chargée, et la vérification de son
source Java afin de produire le fichier .class. Le chargement d’une appartenance au graphe d’héritage effectuée. Cette passe vérifie la
librairie en code natif est à la charge du programmeur. présence des méthodes appelées et des champs désignés par les
L’édition de lien permet d’intégrer la classe chargée au sein du instructions de cette classe, l’absence indiquant que les règles de
chargeur de classe concerné de la machine. Cette étape est compatibilité binaire ne sont pas respectées. Les types des instruc-
constituée d’une vérification, d’une préparation et éventuellement tions de manipulation des champs sont comparés aux signatures
d’une résolution. La vérification assure que le fichier est bien déclarées et présentes dans le champ constant_pool. À la fin de
formé. La préparation consiste en l’allocation des variables de cette passe, certaines implémentations de chargeur peuvent
classes. La résolution dans certaines implémentations convertit les effectuer des substitutions dans le flot des instructions et les
références symboliques en références internes de la machine. instructions avec des opérandes symboliques peuvent être
substituées par des opérandes destinés à la machine.
À la suite de l’édition des liens, l’initialisation de la classe est
effectuée. Elle consiste à exécuter le bloc statique de la classe, les Cette phase de vérification permet à la machine de s’affranchir de
instructions de ce bloc sont regroupées au sein de la méthode l’exécution des tests des limites de la pile, du contrôle des types des
interne nommée <clinit>( ). Cette méthode n’est exécutée qu’une arguments des instructions et de la validité des accès en mémoire
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

seule fois au chargement de la classe, elle contient en général les locale. Cependant, cette étape de vérification peut s’avérer coûteuse
initialisations des variables de classe. en temps d’exécution. Elle est difficile à valider. La découverte
récente d’un problème de sécurité en Java 2 [3] démontre, si cela
Exemple était nécessaire, que cette phase reste perfectible.
Classe Point : le chargement de cette classe induit le chargement
de la classe héritée [Link]. Si celle-ci n’est pas présente
en machine, la classe [Link] est chargée à la première
occurrence de l’appel de la méthode distOrigin. La classe Point a un 4. Jeu d’instructions/source
bloc d’initialisation de la variable de classe.
Java
3.5 Vérification du fichier compilé
La machine Java comporte 225 instructions. L’approche
retenue ici est de présenter un sommaire des familles
La première étape de l’édition des liens est la phase de d’instructions accompagné de deux exemples représentatifs
vérification. Cette phase contribue à la notion de sécurité (§ 4.1). Ensuite, les différentes familles d’instructions sont
prônée et effective par les concepteurs du langage. Cette phase proposées de manière ascendante et progressive. Après le
de vérification se déroule en quatre passes. Elle est constituée détail du format des instructions Java (§ 4.2), cette présenta-
d’une analyse syntaxique (passe 1), d’une vérification séman- tion débute par les instructions nécessaires aux évaluations
tique (passes 2 et 3), et de la vérification de la compatibilité d’expressions arithmétiques (§ 4.3) et se poursuit par les
binaire (passe 4). instructions de contrôle (§ 4.8), les instructions d’invocation
de méthodes de classes (§ 4.11) et d’instance (§ 4.12), et enfin
les instructions de mise en œuvre de l’héritage (§ 4.14).
Passe 1 : cette étape vérifie que le fichier compilé est au bon
format. Les premiers octets doivent correspondre au nombre
« magique ». Tous les attributs ont la bonne longueur et le fichier
n’est pas tronqué et ne possède pas d’octets supplémentaires. Le 4.1 Exemples
champ constant_pool ne doit pas contenir des valeurs d’étiquettes
Les familles d’instructions peuvent se scinder en deux groupes :
non répertoriées.
– les familles d’instructions nécessaires à la gestion des
Passe 2 : cette étape correspond à une vérification sémantique des variables locales et de classes, de la pile d’évaluation, du contrôle
champs du fichier compilé, à l’exception du code vérifié dans la et les méthodes de classe ;
passe suivante. Les classes et les méthodes dénotées final ne sont – les familles d’instructions liées à la gestion des objets.
pas dérivées. Chaque classe possède une classe héritée, sauf
[Link]. La cohérence du champ constant_pool est validée, Les familles d’instructions non liées aux objets sont :
chaque entrée est testée. Une entrée référencée comme un type – arithmétiques et logiques (§ 4.3) iadd, imul... ;
CONSTANT_Class_info doit désigner pour le champ name_index une – manipulation de la pile (§ 4.4) dup, pop... ;
entrée de type CONSTANT_NameAndType_info. Toutes les signatu- – gestion des variables locales et des constantes (§ 4.5) aload,
res des champs et paramètres sont vérifiées syntaxiquement. iload, istore, iconst... ;

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 9

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

– gestion des conversions entre types primitifs (§ 4.6) i2l... ;

– contrôle, branchement (§ 4.7) et (§ 4.8) if_icmplt..., goto, jsr...,
return ;
– accès aux variables de classe (§ 4.10) getstatic, putstatic ;
– appels de méthodes de classe (§ 4.11) invokestatic ; 2 : resultat
– gestion des exceptions (§ 4.17) athrow. 1 : compte
Les familles d’instructions liées à la gestion des objets sont : vars 0:n
– allocation de l’espace mémoire (§ 4.12) et (§ 4.13) new,
Segment d’activation
newarray... ;
frame de la méthode f
– accès aux champs d’instance (§ 4.12) getfield, putfield... ;
– accès aux éléments de tableau (§ 4.13) aaload, aastore... ; 2:y 2:y
– appels de méthodes d’instance (§ 4.14) invoke_virtual, 1 : operande 1 : operande
invoke_super ;
vars 0 : args 0 : args
– gestion des conversions entre classes (§ 4.16) check_cast,
instance_of ; Segment d’activation Segment d’activation
– gestion de la concurrence (§ 4.18) monitor_enter, monitor_exit. frame de la méthode main de la méthode main

Exemple 1 : variables locales et méthodes statiques (figure 9) a avant exécution de f b exécution de f

Ce premier exemple montre le code source Java et les instructions

engendrées appartenant aux familles d’instructions non liées aux Figure 10 – Pile des blocs d’activation
objets. Ce code source Java implémente deux méthodes de classe :
main et f. Le code de la méthode main consiste en l’appel de la
méthode de classe [Link] suivi de l’appel d’une autre Exemple 2 : objets et méthodes d’instance (figure 11)
méthode de classe f. Après avoir placé les paramètres sur la pile,
l’appel de la méthode de classe parseInt est effectué par l’instruction L’exécution de ce deuxième exemple engendre la création d’un
invoke_static ainsi que pour l’exécution de f. Le code de la méthode f objet et les appels d’un constructeur et d’une méthode d’instance. Ce
utilise une itération implémentée par les instructions goto et if_cmplt. sont les instructions liées à la gestion des objets qui sont générées
sur cet exemple. Le code source Java de la classe Exemple2 implé-
La pile des segments d’activation avant et pendant l’exécution de f mente la classe interne et statique Nœud, le constructeur sans para-
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

est représentée figure 10. mètre de la classe Exemple2 ainsi que la méthode de classe main.
Nota : toutes ces instructions sont détaillées dans la suite du paragraphe 4.
La création d’une instance de la classe Exemple2 engendre la
réservation de la place en mémoire des objets par l’exécution de
l’instruction new. Les appels des constructeurs de la classe et des
classes héritées sont réalisés par l’instruction invokesuper. Sur cet
exemple, la classe héritée par Exemple2 est la classe
Source Java Instructions générées
java/lang/Object. Ce constructeur alloue une nouvelle instance de la
classe Nœud et déclenche la méthode suivant, réalisée par l’instruc-
public class Exemple1{
tion invoke_virtual. La lecture de la donnée d’instance debut utilise
public static void main (String [ ] args) { l’instruction getfield.
int operande = [Link] (args [0]) ; aload_0, iconst_0, aaload
La création d’une instance de la classe Nœud engendre l’appel
invoke_static, « parseInt » des constructeurs de la classe héritée puis du constructeur par
istore I défaut de la classe Nœud. Notons l’absence de constructeur dans
la source Java et la présence normale de celui-ci dans le code
// voir figure 10 généré. L’affectation de la donnée d’instance suivante utilise
int y = f (operande) ; iload_I l’instruction putfield.

invoke_static, « f », istore_2
La pile des segments d’activation et la mémoire des objets,
obtenues après l’allocation de l’instance Exemple2 dans la
} méthode de classe main sont représentées figure 12.
static int f (int n) {
int compte = 1 ; iconst_1, istore_1 4.2 Notation et format des instructions
int resultat = 1 ; iconst_1, istore_2
La notation est xx, yy pour les opérandes : xx est l’octet de poids
// voir figure 10 fort, yy de poids faible. La valeur des octets est donnée en
[Link] décimal. Le mot constant_pool est conservé. La description des
opérations engendrées utilise les actions : empiler, dépiler et
while (compte < n) { début : sommet sur la pile d’évaluation. Des variables intermédiaires sont
compte++ ; iinc, 1, 1, également utilisées. La description de ces opérations ne fournit
que des éléments d’implémentation des instructions de la
resultat = resultat * compte ; iload_2, iload_1, imul, istore_2 machine.
} test : iload_1, iload_2, Nota : pour en savoir plus, une description plus complète des instructions est donnée
if_icmplt, début dans les ouvrages [2] [4].

return resultat ; iload_2, ireturn Les zones mémoires ainsi que les registres de la machine
conservent les littéraux définis par SUN présentés au
Figure 9 – Variables locales et méthodes statiques paragraphe 2.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 10 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

Source Java Instructions générées

public class Exemple2 {

private static class Noeud {
private Noeud suivant ;
void suivant (Noeud n) {
this . suivant = n ; aload_0, aload_1, putfield, « suivant »
return
}
// le constructeur par défaut de cette classe
// soit « Exemple2$Noeud.<init> () V »
aload_0
invokesuper, « java/lang/Object.<init> () V »
return
}
private Noeud debut ;
Exemple2 ( ) {
debut = new Noeud ( ) ; aload 0,
invokesuper, « java/lang/Object, <init> ()V »
aload 0, new, « Exemple2$Noeud »
dup
invokesuper, « Exemple2$Noeud. <init> () V »
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

putfield, « Exemple2. debut »

debut . suivant (debut) ; aload_0, getfield, « Exemple2 . debut » //le
paramètre
aload 0, getfield, « Exemple2 . debut » //l'instance
invokevirtual, « exemple2$Noeud . suivant (Noeud) »
return
}
// ...
public static void main (String [] args) {
Exemple2 ex2 = new Exemple2 () ;
// voir figure 12

Figure 11 – Objets et méthodes d’instance

Mémoire des objets Instance de

[Link]
Classe
Object
super

Champs d’instance de Classe

1 : ex2 Exemple2
vars [Link]
0 : args + champs d’instance
Segment d’activation debut de Exemple2
frame super
de la méthode main
Classe
Champs d’instance de Exemple25
[Link] Noeud
+ champs d’instance
suivant de Exemple25 Noeud

Figure 12 – Pile des segments d’activation et mémoire des objets

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 11

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

Le format d’une instruction consiste en un code opération Tableau 2 – Instructions dédiées aux expressions
spécifiant l’opération à exécuter suivi de 0 à plusieurs arithmétiques en fonction du type des opérandes
opérandes représentant les paramètres ou les données de Opéra-
l’instruction. Le code opération d’une instruction est un octet byte short int long float double
teurs Java
et l’opérande une séquence d’octets, les octets de poids forts
étant en tête de la séquence. La mémoire de code est une bipush sipush iconst lconst fconst dconst constante
mémoire d’octets et seules deux instructions nécessitent un numérique
alignement en mots de 32 bits.
iadd ladd fadd dadd +
isub Isub fsub dsub –
Exemple
imul lmul fmul dmul *
Mémoire de code {03,17,10,01} :
03 est le code opération de l’instruction iconst_0. idiv ldiv fdiv ddiv /
17 représente le code opération de sipush. irem lrem frem drem %
L’opérande est constitué de deux octets représentant un mot de ineg lneg fneg dneg – (unaire)
16 bits dont la valeur entière est (10 * 256) + 01 ; 10 est la valeur de
l’octet de poids fort et 01 celle de l’octet de poids faible. ishl lshl <<
ishr lshr >>
4.3 Évaluationd’expressionsarithmétiques iushr lushr >>>
L’évaluation d’une expression arithmétique utilise une pile iand land &
d’opérandes. Les instructions référencent de manière implicite ior lor |
cette pile : accès au sommet lors d’une opération unaire et égale-
ment au sous-sommet lors d’une opération binaire, le ixor lxor ^
sous-sommet étant alors le premier opérande.

Exemple Nous retrouvons les instructions de manipulation de constantes et

L’expression 3/2 devient « empiler(3),empiler(2), diviser ». L’opéra- les opérations pour les autres types primitifs tels que les flottants
tion diviser place au sommet de pile le résultat. La séquence des (float, double ) et les entiers sur 64 bits (long ). Les expressions utili-
sant les opérateurs binaires Java comme & | ont leur correspondant
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

opérations engendrées lors de l’exécution de l’instruction diviser est

la suivante : {opérande2 = depiler(); opérande1 = depiler(); empi- en instruction de la machine. Le & entre deux entiers génère l’ins-
ler(opérande1/opérande2)}. truction iand et le « | » entre deux entiers sur 64 bits engendre l’ins-
truction lor. La première lettre du mnémonique indique le type des
Les instructions suivantes placent des constantes sur la pile opérandes (b/byte, s/short, i/int, l/long, f/float, d/double, a/reference ).
iconst_0 iconst_1 iconst_2 bipush,xx sipush,xx,yy ldc ldc_w ldc2_w... Le tableau 2 récapitule les différentes instructions générées en fonc-
Les constantes empilées sont contenues dans le code opération de tion du type des opérandes et de l’opération effectuée.
l’instruction où la constante est formée de l’opérande en un ou
deux octets suivant l’instruction, ou bien l’opérande représente un
index dans le champ constant_pool spécifiant la constante à empi- 4.4 Opérations de manipulation de la pile
ler. Les opérations arithmétiques du langage Java ont leurs ins-
tructions correspondantes, l’addition entre deux entiers se nomme Les instructions de duplication du sommet de pile ainsi que
iadd, la division idiv et la multiplication imul. l’inversion du sommet de pile avec le sous-sommet sont présentes
dans la machine Java (tableau 3). Ces instructions ne sont pas
Afin de simplifier cette introduction aux instructions de la typées. Elles manipulent les opérandes placés sur la pile dont la
machine Java, l’exemple suivant utilise des expressions arith- taille est d’un ou de deux mots de 32 bits. Un opérande sur un mot
métiques avec des nombres entiers. Ces expressions de 32 bits (types byte, short, int, float et type référence de Java)
constituées uniquement de nombres entiers sont normale- occupe une place ; un opérande sur deux mots de 32 bits (types
ment évaluées par le compilateur Java alors que pour long et double de Java) occupe deux places. L’opération de retrait
l’exemple suivant, toutes les instructions ont été générées d’un mot de 32 bits correspond à l’instruction pop et le retrait d’un
sans aucune évaluation. mot de 64 bits correspond à l’instruction pop2. L’instruction dup_x1
effectue une duplication du sommet de pile, le sommet dupliqué
est placé sous le sous-sommet. Les instructions dup_x2, dup2_x1,
dup2_x2 diffèrent de dup_x1 par le format des opérandes utilisés et
Exemple la position des opérandes après exécution.
L’expression arithmétique « 3 + 2 * 6/2 » devient en notation
postfixée « 3 2 6 * 2 / + » et son calcul utilise la pile d’évaluation afin
de produire le résultat.
4.5 Variables locales
Instructions Opérations engendrées
iconst_3, empiler (3) Les instructions sont résumées dans le tableau 4.
iconst_2, empiler (2) À l’appel d’une méthode, un segment d’activation est réservé sur
bipush, 06, empiler (6) la pile d’exécution du thread courant. Le registre frame indique la
imul, empiler ( depiler ( ) * depiler ( ) ) base de ce segment. Celui-ci contient une zone mémoire pour les
variables locales dont la base est référencée par le registre vars.
iconst_2, empiler (2)
La lecture d’une variable locale de type entier utilise l’instruction
idiv, opr2=depiler ( ) ; opr1=depiler ( ) ;
iload ; cette instruction empile la valeur entière contenue en
empiler (opr1/opr2)
mémoire locale, dont l’adresse est calculée en ajoutant l’opérande
iadd, empiler ( depiler ( ) + depiler ( ) ) de l’instruction iload à la valeur du registre vars.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 12 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

Tableau 3 – Instructions de manipulation de la pile

Opérations de retrait pop pop2

Opérations de duplication dup dup2 dup_x1 dup2_x2 dup_x2 duxp2_x2

Échange sommet/ sous-sommet swap

Tableau 4 – Instructions dédiées aux variables Tableau 5 – Instructions dédiées

locales aux conversions explicites
Types de variables Types de destination
Type
byte short int long float double source
byte short int long float double
iload lload fload dload
int i2b i2s i2l i2f i2d
istore lstore fstore dstore
long l2i i2f i2d
iinc
float f2i f2l f2d

L’écriture utilise l’instruction istore, cette instruction affecte la double d2i d2l d2f
variable locale par le sommet de pile. Le déplacement par rapport
au registre vars est obtenu de la même façon.

4.7 Expressions booléennes

Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

4.6 Conversions implicites et explicites

En Java, lors d’une affectation, si la taille du type primitif de Ce paragraphe décrit les instructions rencontrées lors de
destination est supérieure à la taille du type source, la conversion l’évaluation d’une expression booléenne.
est implicite ; sinon, un changement de type explicite est néces-
saire. Plusieurs instructions sont chargées de ces conversions
entre types primitifs (tableau 5). La conversion implicite est une Exemple 3 : usage des opérateur (figure 13).
troncature au format du destinataire comme i2b et i2s ou bien une Les résultats sont de type entier, les instructions binaires déjà
extension de format comme i2l (de 32 en 64 bits). mentionnées au paragraphe 4.2 effectuent les opérations logiques.

Instructions Source Java Opérations engendrées

boolean b, b1, b2, b3 ; empiler (5) ;

iconst_1 b = true ; empiler (1) ;
istore_0 frame [vars + 0] = depiler () ;
iconst_0 b1 = false ; empiler (0) ;

istore_1 b1 = false ; frame [vars + 1] = depiler () ;

iload_0b2 = b & b1 ; i=i+1; empiler (frame [vars+0]) ;

iload_1 empiler (frame [vars+1]) ;
iand empiler (depiler () + depiler() ) ;
istore_2 frame [vars+2] = depiler () ) ;
iload_0 b3 = b b1 ; empiler (frame [vars+0] ) ;
iload_1 empiler (frame [vars+1] ) ;
ior empiler (depiler () \ depiler() ) ;
istore_3 b1 = false ; frame [vars + 3] = depiler () ;

Figure 13 – Usage des opérateurs

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 13

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

Tableau 6 – Instructions dédiées de contrôle

int long float double reference
lcmp
fcmpl dcmpl
fcmpg dcmpg
if_TcmpOP (1) if_acmpeq, if_acmpne
ifnull, ifnonnull
(1) OP : eq, ne, lt, gt, le, ge.
Tcmp : empiler (comp (depiler (), depiler ()).
avec T : f, l, d.
avec comp (op1, op2) = 0 si op1 == op2 ; 1 si op2 > op1 ; – 1 si op1 < op2.

Numéro Instructions Source Java Opérations engendrées

0 iconst_5 int i = 5 ; empiler (5) ;

1 istore 0 frame [vars + 0] = depiler () ;
2 goto, 00, 07 while (i < 10) { pc = 9 ;
5 iload 0 i=i+1; empiler (frame [vars+0]) ;
6 iconst_1 empiler (1) ;
7 iadd empiler (depiler () + depiler() ) ;
8 istore_0 frame [vars+0] = depiler () ) ;
9 iload_0 empiler (frame [vars+0] ) ;
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

10 bipush, 10 empiler (10) ;

opr = depiler () ; oprl = depiler () ;
12 if_icmplt, 255, 249, si (oprl < opr2) pc = 5 ;

Figure 14 – Itération et incrémentation

4.8 Instructions de contrôles compilateur. La table est alors remplacée par une liste ordonnée de
couples <clé, adresse de code>. La sélection du code s’effectue en
Les instructions de branchement ont toutes leur code opération comparant séquentiellement la variable de sélection avec la clé de
sur un octet et sont suivies d’un opérande sur deux octets repré- chaque couple afin de déterminer la séquence de code à exécuter.
sentant le déplacement relatif à ajouter au compteur ordinal (pc), si Les deux exemples suivants présentent ces deux instructions.
le saut est effectif. Les opérateurs relationnels de Java ont leurs Notons que ces deux instructions ont leur table interne alignée sur
correspondants en instruction de la machine (tableau 6). Le test un mot de 32 bits, le générateur de code assure cet alignement.
d’égalité entre deux entiers est effectué par l’instruction if_icmpeq.
Sur cet exemple, l’instruction en ligne 12, if_icmplt, effectue le saut Exemple 5 : instruction tableswitch, table d’indirections de
si le premier entier empilé est inférieur au second. Les opérandes taille 2 (figure 15).
ont comme valeur 255,249 soit la valeur – 7. L’adresse de débran-
chement est en 5 (adresse 12-7). La table contient pour i = 0 l’adresse 24, et pour i = 1 l’adresse 29,
elles représentent les adresses de code respectives.
Exemple 4 : itération et incrémentation (figure 14).
Exemple 6 : instruction lookupswitch, liste ordonnée de taille 2
(figure 16)
4.9 Instructions pour la sélection
La liste contient les couples <0,32> et <1000,27>, soit en absolu
(switch/case ) les couples <0,69>,<1000,64> (69 pour 37 + 32).
Les instructions tableswitch et lookupswitch implantent
l’instruction Java switch/case. L’instruction tableswitch est suivie
d’une table dans laquelle est recensée, pour chaque valeur possible 4.10 Variables de classes
de l’expression testée, l’adresse de code correspondant. La taille de
cette table est liée aux valeurs des constantes possibles pour Les variables de classes sont assimilables aux variables globales
l’expression de sélection installée par le programmeur. Cette taille d’un programme. L’instruction getstatic place en pile d’évaluation
est égale à la valeur de la constante maximale soustraite de la la valeur d’une variable de classe et l’instruction putstatic range le
constante ayant la valeur minimale. La valeur de l’expression sommet de pile dans la zone des variables associées à chaque
devient l’indice dans cette table auquel se trouve l’adresse de code à classe. Les opérandes de ces instructions sur deux octets
exécuter. Si cette table est trop importante, ou les valeurs de sélec- représentent l’indice dans le champ constant_pool. À cet indice se
tion trop éparses, l’instruction lookupswitch est préférée par le trouve la désignation symbolique complète du champ de classe.

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 14 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

Instructions Source Java Opération engendrées

iconst_0 int i = 0 empiler (0) ;

istore_0 frame [ vars + 0 ] = depiler () ;
iload_0 switch (1) { empiler (frame [ vars + 0 ] ) ;
tableswitch
00, 00, 00, 34 défault : 34
00, 00, 00, 00 case 0 : i = 0 ; break ; low : 0
00, 00, 00, 01 case 1 : i = 1 ; break ; high : 1
00, 00, 00, 24<0/24>
00, 00, 00, 29<1/29>
24 iconst_0 empiler (0) ;
istore_0 frame [ vars + 0 ] = depiler () ;
goto, 00, 08 pc = 34 ;
29 iconst_1 empiler (0) ;
istore_0 frame [ vars + 0 ] = depiler () ;
goto, 00, 03 } pc = 34 ;
34 return

Figure 15 – Instruction tableswitch, table d’indirection de la taille 2

Instructions Source Java Opérations engendrées

Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

34 iconst_0 int j = 0 ; empiler (0) ;

35 istore_1 frame [vars + 0] = depiler () ;
36 iload_1 switch (j) { empiler (frame [vars+1]) ;
37 lookupswitch
00,00 // 2 octets pour un alignement en mots de 32 bits
00, 00, 00, 74 case 1 000 : j = 2 ; break ; default : 74
00, 00, 00, 02 case 0 : j = 0 ; break ; npairs : 2
48*00, 00, 00, 00, 00, 00, 00, 32, <0/<0-69>>
56*00, 00, 03, 232, 00, 00, 00, 27 <1/<1000-64>>
64 iconst_2 empiler (2) ;
istore 1 frame [vars + 1] = depiler () ;
goto, 00, 08 pc = 74 ;
69 iconst 0 empiler (0) ;
istore_1 frame [vars +1] = depiler () ;
goto, 00, 03 pc = 74 ;
74 return }

Figure 16 – Instruction loockupswitch, liste ordonnée de taille 2

4.11 Appel de méthodes de classes cite d’une classe Java, ce bloc est exécuté une seule fois au
chargement de la classe. Les retours de fonction s’exécutent à
L’instruction invokestatic réalise l’appel d’une méthode de l’aide d’instructions liées aux types retournés (tableau 7).
classe, l’opérande sur deux octets indiquant l’entrée dans le
champ constant_pool à laquelle se trouve la désignation de la
méthode appelée. La recopie des arguments dans la zone frame Tableau 7 – Instructions de retour de fonction
indicée par le registre vars est à la charge de la machine. Le
segment d’activation contient l’adresse de retour, l’adresse du int long float double reference
segment de l’appelant ainsi que la zone des variables locales,
paramètres inclus. Notons que la méthode avec l’identificateur
ireturn lreturn freturn dreturn areturn
interne <clinit>()V est associée au bloc statique implicite ou expli-

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 15

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

Instructions Source Java Opérations engendrées

public class MethodesDeClass :

statie void m () {
invokestatic, 00, 05 m1 () MethodesDeClasse . m1 ( ) ; // ()V
iconst_5 int i = 5 ; empiler (5) ;
istore_0 frame [vars + 0] = depiler ( ) ;
iload_0 empiler (frame [vars + 0]) ;
invokestatic, 00, 06 m2 (i) MethodesDeClasse . m2 ( ) ; // (I) V
iload_0 int j = f (i) empiler (frame [vars + 0]) ;
invokestatic, 00, 04 MethodesDeClasse . f ( ) ; // (I) I
istore 1 frame [vars + 1] = depiler ( ) ;
return } restaurer ;
static void m1 () {}
return restaurer ;
static void m2 (int k) {}
return restaurer ;
public static int f (int x) {
return x + 1
iload_0 empiler ( frame [vars + 0] ) ;
iconst_1 empiler (1)
iadd empiler (depiler ( ) + depiler ( ) ) ;
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

ireturn} restaurer ;

Figure 17 – Instructions invokestatic et return

Exemple 7 : instructions invokestatic et return (figure 17)

L’instruction invokestatic,00,05 référence la cinquième entrée du Extrait du champ constant_pool
champ constant_pool à laquelle est mentionnée la classe propriétaire (fichier [Link])
ainsi que le nom et le type de la méthode à déclencher (entrée [9] soit le
nom m1 et la signature () V, entrée [23] et entrée [11] respectivement). [4] tag: 10 class_index: 1 name_and_type_index: 8
[5] tag: 10 class_index: 1 name_and_type_index: 9
4.12 Allocation des objets, variables [6] tag: 10 class_index: 1 name_and_type_index: 10
d’instance, appel du constructeur [8] tag: 12 class_index: 20 descriptor_index: 12
[9] tag: 12 class_index: 23 descriptor_index: 11
L’allocation des objets en Java est réalisée par l’instruction new [10] tag: 12 class_index: 24 descriptor_index: 13
suivie de deux opérandes représentant un index dans le champ [11] tag: 1 length: 3 () V//m1
constant_pool. À cet index se trouvent toutes les informations sur [12] tag: 1 length: 4 (I) I//f
l’instance de la classe à créer. À la création de l’instance, une réfé-
[13] tag: 1 length: 4 (I) V// m2
rence est retournée par l’allocateur des objets ; cette référence est
l’adresse directe ou indirecte du descripteur de l’objet en mémoire. [20] tag: 1 length: 1 f
Ce descripteur contient les données d’instance et une référence sur [23] tag: 1 length: 2 m1
la classe d’appartenance (figure 7). Ces références occupent un [24] tag: 1 length: 2 m2
mot de 32 bits. À la suite d’une allocation réussie, le constructeur
de l’instance est appelé par l’instruction invokespecial,xx,yy. Le
code du constructeur comporte l’appel du constructeur de la classe de méthode d’instance. La machine Java doit réaliser la copie des
héritée. Ce constructeur est déclenché préalablement à toute arguments placés sur la pile des opérandes vers la zone du
instruction utilisant l’instance allouée. En Java, seule la classe segment d’activation, zone indicée par le registre vars.
[Link] ne possède pas de classe héritée.
Les accès aux variables d’instance sont effectués par les instruc-
Les références sont accessibles par les instructions aload,
tions getfield et putfield, ces variables sont accédées par la réfé-
aload_n et astore, astore_n ; aload, aload_n placent une référence
rence de l’instance dont elles sont issues. Les deux opérandes de
sur la pile d’évaluation et astore, astore_n rangent le sommet de
ces instructions précisent l’entrée du champ constant_pool à
pile dans la zone des variables locales. La référence de l’objet rece-
laquelle se trouvent les informations sur les champs utilisés. La
veur est placée sur la pile d’évaluation avant tout appel de
référence de l’instance est sur la pile d’évaluation.
méthodes ou de constructeurs. À chaque exécution du
constructeur, un segment d’activation est créé et la pile d’évalua-
tion contient les arguments et la référence de l’objet receveur. En Exemple 8 (extrait de [H 3 088]) : instructions new, invokespe-
conséquence, l’instruction aload_n ou aload,xx précède tout appel cial, putfield, getfield (figure 18).

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 16 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

4.14 Héritage, appel de méthode

Extrait du champ constant_pool d’instance et liaison dynamique
(fichier [Link], figure 17)
L’instruction invokevirtual effectue la recherche de la méthode à
[1] tag: 7 name_index: 22 partir de la classe constatée de l’objet receveur. L’instruction est
[3] tag: 7 name_index: 27 suivie de deux opérandes indiquant l’entrée dans le champ
[4] tag: 10 class_index: 3 name_and_type_index: 9 constant_pool. Cette entrée fournit le nom et la signature de la
[5] tag: 10 class_index: 1 name_and_type_index: 9 méthode. La référence de l’objet receveur est placée préalable-
ment sur la pile d’évaluation par l’instruction aload ou aload_n. La
[7] tag: 9 class_index: 1 index_and_type_index: 12 recopie des paramètres de la pile d’évaluation vers la zone des
[8] tag: 9 class_index: 1 name_and_type_index: 13 variables locales de la méthode appelée est à la charge de la
[9] tag: 12 class_index: 18 descriptor_index: 15 machine.
[12] tag: 12 class_index: 30 descriptor_index: 20
L’algorithme de recherche séquentielle d’une méthode depuis la
[13] tag: 12 class_index: 31 descriptor_index: 20 classe effective de l’objet en parcourant l’arbre d’héritage est
[15] tag: 1 length: 3 ()V inefficace et non déterministe en temps. Une technique utilisant
[18] tag: 1 length: 6 <init> une table des méthodes d’instance, table créée au chargement
pour chaque classe, qui substitue la recherche séquentielle par une
[20] tag: 1 length: 1 1 indirection est présentée au paragraphe 4.18.
[22] tag: 1 length: 5 Point
[27] tag: 1 length: 16 java/lang/Object
[30] tag: 1 length: 1 x 4.15 Interface
[31] tag: 1 length: 1 y
L’instruction invokeinterface réalise les mêmes opérations que
l’instruction invokevirtual, à l’exception de la signature de la
4.13 Tableaux méthode qui est issue d’une interface. La recherche est effectuée
selon le même algorithme et cette méthode peut être héritée ou
En Java, les tableaux sont des objets. Un tableau hérite implici- implémentée par la classe. Les opérandes désignent les informa-
tement de la classe [Link]. Les tableaux sont gérés par tions sur l’interface, la méthode choisie dans le champ
un ensemble d’instructions spécifiques (tableau 8). La création constant_pool ainsi que le nombre d’arguments (+ 1) de la méthode.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

d’une table est assurée par les instructions newarray, anewarray

et multianewarray. L’instruction newarray est utilisée afin de créer
des tables d’éléments de type primitif, l’opérande associé indi- Exemple 9 (extrait de [H 3 088]) : instruction invokeinterface
quant le type. L’instruction anewarray alloue un tableau de réfé- (figure 19)
rences, l’opérande sur deux octets formant un index dans le
champ constant_pool où se trouve la description de la classe dont
les éléments sont issus. L’instruction multianewarray est réservée
à l’allocation de tableaux à plusieurs dimensions. 4.16 Test d’appartenance et conversion
L’instruction de lecture iaload retire de la pile l’index et la de type
référence associée au tableau, l’élément entier désigné de la table
est empilé. Pour l’instruction d’écriture iastore, la valeur entière,
l’index et la référence du tableau sont préalablement empilés. L’instruction instanceof permet de tester si la référence placée
au sommet de pile est une instance de classe ; le résultat de type
Les valeurs associées aux types primitifs sont : entier (0 ou 1) est placé sur la pile. Cette instruction implémente
– byte : 8 ; l’opérateur Java instanceof.
– short : 9 ;
– int : 10 ; L’instruction checkcast lève une exception de type
– long : 11 ; [Link] si l’objet n’est pas une instance de la
– float : 6 ; classe ou de l’interface spécifiée. Cette instruction implémente les
– double : 7 ; changements de type précisés dans le code source Java. Les opé-
– char : 5 ; randes de ces deux instructions représentent un index dans le
– boolean : 4. champ constant_pool précisant la classe testée.

Tableau 8 – Instructions dédiées à la gestion des tableaux

Types
Opérations
byte short int long float double char boolean reference
Lecture baload saload iaload laload faload daload caload baload aaload
Écriture bastore sastore iastore lastore fastore dastore castore bastore aastore
Allocation d’une table d’éléments de type primitif : newarray
Allocation d’une table d’objet : anewarray
Allocation d’une matrice : multianewarray
Longueur : arraylength

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 17

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

Instructions Source Java Opérations engendrées

public class Point extends [Link] {

private int x, y ;
// le constructeur par défaut Point.
<init> () V
aload_0 empiler (this) ;
invokespecial, 00, 04 java/lang/Object.
<init> () ; // () V
return
public void moveTo (int nx, int ny) {
aload 0 this.x = nx ; empiler (this) ;
iload 1 empiler (frame [vars + 1 ] ) ;
ref = depiler () ;
putfield, 00, 07 ((Point) ref) . x = depiler () ;
aload_0 y = ny ; empiler (this) ;
iload_2 empiler (frame [frame [vars + 2]) ;
ref = depiler () ;
putfield, 00, 08 ((Point) ref) . y = depiler () ;
return }
public int getX () {
aload_0 return x ; empiler (this) ;
ref = depiler () ;
getfield, 00, 07 } empiler ((Point) ref) . x) ;
ireturn
public int getY () {
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

aload_0 return y ; empiler (this) ;

ref = depiler () ;
getfield, 00, 08 } empiler ((Point) ref) . y) ;
ireturn
public static void m () {
new, 00, 01 Point p = new Point () ; empiler (new Point() ) ;
dup empiler (sommet () ) ;
invokespecial, 00, 05 Point . <init> () ; // () V
astore_0 frame [vars + 0] = depiler () ;
return }

Figure 18 – Instructions new, invokespecial, putfield, getfield

Instructions Source Java Opérations engendrées

interface Mobile {
public void moveTo (int nx, int ny) ;
}
public class PointM implements Mobile {
private int x, y ;
public void moveTo (int nx, int ny) {x = nx ; y = ny ; }
public static void m ( ) {
Mobile m = new PointM ( ) ;
aload_0 [Link] (10, 10) ; empiler (m) ;
bipush, 10 empiler (10) ;
bipush, 10 empiler (10) ;
invokeinterface, 00, 06, 03, 00 [Link] ( ) ; / / (II) V
return

Figure 19 – Les instructions invokeinterface

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 18 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

4.17 Exceptions Le sous-programme est de 21 à 24 et la sauvegarde du pc de

retour est effectuée en frame[vars + 2]. Une exécution sans levée
d’exception engendre la séquence 0..9,21 à 24,12,26. Une levée
La gestion des exceptions en Java est assurée par l’instruction d’exception lors de l’exécution des instructions aux adresses 0 et 2,
athrow. Cette instruction utilise une instance de la classe filtrée par la clause catch, engendre la séquence 5,6,9,21 à 24,12,26.
[Link]. Elle est placée au sommet de la pile. La Une levée d’exception pendant l’exécution des instructions aux adres-
recherche de la clause catch appropriée est effectuée. Lorsque le ses 0 et 9, qui n’est pas filtrée par la clause catch, engendre la
choix est validé, la table liée à la clause catch sélectionnée indique séquence 15,16,21 à 24,19,20. L’exception est à nouveau propagée
les adresses de branchement en fonction du type de l’exception. par l’instruction athrow en ligne 20.
Cette table indique l’adresse du bloc try/catch, l’adresse du
gestionnaire de l’exception et le type de l’exception par un index
dans le champ constant_pool. 4.18 Threads
L’exemple 11 reprend la méthode distOrigin de la classe Point Dans la machine, les threads partagent une seule zone
extraite de [H 3 088] et enrichie d’une levée d’exception en cas de contenant tous les objets alloués. L’accès à ces données doit être
dépassement de la valeur maximale d’un entier. L’exemple 13 coordonné et protégé. La machine Java implémente les
présente la clause try/finally, le bloc d’instructions de la clause mécanismes de verrou et de moniteur qui assurent l’exclusion
finally doit toujours être exécuté dès l’entrée dans le bloc try. Pour la mutuelle et la synchronisation des processus lors de l’accès
machine, ce bloc est assimilable à un sous-programme appelé par concurrent à une ressource. Pour chaque objet, la machine Java
l’instruction jsr et dont le retour est assuré par l’instruction ret. gère un compteur et une file d’attente. Si la valeur du compteur est
nulle, l’objet est libre d’accès. À chaque usage de l’objet, le
compteur est incrémenté par l’instruction monitorenter. Quand le
Exemple 10 : filtrage de l’exception, propagation par un nouvel processus n’utilise plus la ressource, le compteur est décrémenté
athrow (figure 20) par l’exécution de l’instruction monitorexit.
Si l’exception se produit entre 0 et 13, le branchement a lieu en 16
si l’exception est de type [Link]. Notons que la classe 4.19 Optimisations
de la table correspond si c’est une superclasse de l’instance levée.
4.19.1 Pseudo-instructions (-quick)
Exemple 11 : clause try/finally, instructions jsr et ret (figure 21) L’accès au champ constant_pool de certaines instructions peut
L’opérande de l’instruction jsr représente l’adresse à laquelle se être supprimé et remplacé par un accès direct plus rapide. La
trouve le sous-programme associé au bloc finally. L’opérande et lecture du champ constant_pool est un élément de sécurité et de
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

l’instruction ont une taille de trois octets, l’adresse de retour (pc + 3) fiabilité de Java et de son interprétation. Le principe est d’effectuer
est empilée. La première instruction du sous-programme sauve le la vérification une seule fois, à la première occurrence de l’instruc-
sommet de pile en mémoire locale. L’instruction ret correspond au tion. Celle-ci est alors remplacée par sa version optimisée avec le
retour de sous-programme ; elle utilise cette sauvegarde en mémoire suffixe _quick ; les opérandes ont alors une autre signification. Ce
locale afin de poursuivre l’exécution. type d’optimisation concerne les instructions de lecture des

Instructions Source Java Opérations engendrées

public static void m ( ) throws Exception {

try {
0 new, 00, 01 Point p = new Point () ; empiler (new Point () ) ;
3 dup empiler (sommet () ) ;
4 invokespecial, 00, 06 Point. <init> () V
7 astore_0 frame [vars + 0] = depiler () ;
8 aload_0 int i = [Link] () ; empiler (frame [vars + 0] ;
9 invokevirtual, 00, 09 [Link] ( ) ; // 1
12 istore_1 } catch (Exception e) { frame [vars + 1] = depiler () ;
13 goto, 00, 06 pc = 19 ;
16 astore_0 throw e ; frame [vars + 0] = depiler () ;
17 aload_0 empiler (frame [vars + 0]) ;
athrow propager ;
return }

// exception : start_pc, end_pc, handler_pc, catch_type

// _table | 0| 0, 13, 16, 2 ([Link])

Figure 20 – Filtrage de l’exception, propagation par un nouvel athrow

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 19

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

Instructions Source Java Opérations engendrées

public static void m ( ) {

int i ;
try {
0 iconst_1 i=1;
1 istore_0
2 goto, 00, 07 pc = 9 ;
5 pop } catch (Exception e) { depiler ( ) ;
6 goto, 00, 03 pc = 9 ;
9 jsr, 00, 12 empiler (12) ; pc = 21 ;
12 goto, 00, 14 pc = 26 ;
15 astore_1 frame [vars + 1] = depiler ( ) ;
16 jsr, 00, 05 empiler (19) ; pc = 21 ;
19 aload_1 empiler (frame [vars + 1] ) ;
20 athrow propager ;
21 astore_2 } finally { frame [vars + 2] = depiler ( ) ;
22 iconst_0 } finally {
23 istore_0 }
24 ret, 02 } pc = frame [vars + 2] ;
26 return

/ / exception : start_pc, end_pc, handler_pc, catch_type

/ / _table [ 0] 0, 2, 5, 2 ([Link])
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

/ / _table [ 1] 0, 9, 15, 0 (any)

Figure 21 – Clause try/finally instructions jsr et net

constantes, de manipulation des champs d’instances, d’invocation Exemple 12 : table des méthodes virtuelles (figure 22)
des méthodes de classes ou d’instance et d’allocation des objets.
Cette optimisation consiste à générer pour chaque classe une table
Cela représente vingt-cinq instructions liées principalement à la
manipulation des objets (tableau 9). En développement orienté des méthodes appelée communément table des méthodes
objet, l’impact de ces optimisations en gain de performance est virtuelles (TMV). Le principe est de choisir pour les méthodes mas-
important. Les quelques mesures effectuées [5] le confirment. quées ou surchargées les mêmes indices dans les différentes tables
de chaque classe du même graphe d’héritage. Une nouvelle méthode
est ajoutée à la table avec un nouvel indice. Le code est modifié :
Exemple : lecture de constante l’instruction invokevirtual_quick remplace invokevirtual et les deux
L’optimisation pour ce type d’instructions consiste à générer une nouveaux opérandes représentent l’indice dans la table. Le coût de la
nouvelle table dans laquelle les constantes extraites du champ liaison dynamique est alors le coût d’une seule indirection. Rappelons
constant_pool sont placées. L’opérande de l’instruction devient que le choix de la méthode est effectué en fonction du type constaté
l’indice dans cette table. de l’objet à l’exécution et ne peut être résolu statiquement.
ldc,00,03 : les opérandes désignent l’entrée 3 du champ Ajoutons à la classe Point la méthode public String toString() ;
constant_pool est remplacée par ldc1_quick, 01,__ : l’opérande désigne celle-ci masque la méthode héritée de la classe Object. On obtient le
l’élément de la table à empiler. Le deuxième octet n’est plus utilisé. même indice dans la TMV de la classe Object ainsi que la TMV de la
classe Point. L’instruction invokevirtual, 00, 03 devient
invokevirtual_quick, 00, 05, les opérations engendrées par cette
Exemple : accès aux champs d’instance instruction consistent en l’obtention de la classe constatée de
Le calcul de la taille de chaque champ et de son déplacement dans l’instance et de l’appel de la méthode en TMV.
une zone allouée pour chaque instance est effectué. Le déplacement
devient l’opérande des instructions de lecture et d’écriture des
champs d’instance. 4.19.2 Compilateurs JIT (just-in-time )
getfield,00,03 : les opérandes désignent l’entrée 3 du champ Deux possibilités se présentent pour l’exécution des instructions
constant_pool est remplacée par getfield_quick,01,__ : le premier de la machine Java sur un processeur standard : interpréter les
octet désigne le déplacement dans la zone des données de cette instructions du fichier .class ou poursuivre la phase de compilation
instance. Le deuxième octet n’est plus utilisé. du code jusqu’à l’obtention d’instructions du processeur de la
L’optimisation des instructions d’accès aux champs de classe machine hôte (code natif). Cette phase de compilation a lieu au
adopte les mêmes substitutions : getstatic est remplacée par chargement du fichier .class, on parle alors de compilation à la
getstatic_quick avec comme opérande la valeur de déplacement dans volée ou de compilation just-in-time (JIT).
la zone des variables de classe. La distinction entre les valeurs sur 32 Simuler un processeur Java par l’interprétation des instructions
bits et les valeurs sur 64 bits est effectuée par des instructions nécessite une sélection en fonction du code opération de l’instruc-
dédiées, par exemple l’instruction getstatic2_quick. tion, et en moyenne trois instructions du processeur hôte ainsi que

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 20 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

______________________________________________________________________________________________________ MACHINE VIRTUELLE JAVA (JVM)

importante. Les compilateurs JIT les plus courants tentent

Tableau 9 – Table partielle des occurrences d’éliminer les opérations sur la pile afin de les remplacer par des
des instructions accès aux registres, et effectuent une transcription en code natif.
Instr. Occur. Instr. Occur. Instr. Occur.
Un exemple est le compilateur JIT d’Internet Explorer de Microsoft.
putfield 17 Le taux d’expansion du code est alors de quatre à dix pour les proces-
seurs de la famille 80 × 86.
dup 116 invokevirtual 59
iadd 11 invokesuper 87 Ce type de compilateur est un bon compromis par rapport à un
compilateur Java générant du code natif, mais engendre une
aconst_ portabilité et une sécurité du code produit moindres. L’emploi d’un
33 iinc 118 invokestatic 2
null compilateur JIT doit prendre en compte le gain en performance
iconst_0 169 ifeq 115 new 105 escompté et également le coût en temps d’exécution du
compilateur, ainsi que la taille mémoire nécessaire.
iconst_1 68 ifne 44 newarray 30
bipush 29 if_icmpeq 29 anewarray 1 4.19.3 API JMX (Java Management eXtension )
ldc 35 if_icmpne 29 arraylength 28 Avec les capacités introspectives de Java, la supervision d’une
machine virtuelle ou d’applications Java en cours d’exécution est
iload 62 if_icmplt 148 ifnull 103 possible par l’usage de librairies standard JMX. C’est à l’initiative
d’un consortium d’industriels allant d’IBM à Motorola qu’une défi-
iload_1 179 if_icmpge 58 ifnonnull 68
nition des interfaces pour cette librairie a été spécifiée. L’objectif
getfield- principal de JMX est :
iload_2 312 goto 153 928
quick (1) – la supervision d’applications Java, rendue nécessaire par l’ins-
tallation distante de services ;
iload_3 116 ireturn 161 putfield_quick 192
– le déploiement et de la mise à jour du logiciel sur des
aload_0 1 290 areturn 265 getstatic_quick 54 machines Java en cours d’exécution.
Toute machine virtuelle Java est instrumentée afin d’accepter
invokesuper_
aload_1 350 return 229 142 des requêtes de clients JMX.
quick
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

invoke_virtual_ Exemple : une machine peut ainsi fournir son état mémoire et
aload_2 141 getstatic 25 520
quick accepter de la part d’un client distant un déclenchement du
ramasse-miettes comme le montre la figure 23.
aload_3 227 putstatic 5
aaload 60 getfield 37 Une notification distante à travers le réseau à la suite d’une
anomalie par exemple est en standard avec JMX.
(1) Notons que les valeurs obtenues pour les optimisations de type_quick
sont élévées.
4.19.4 Dalvik machine sous Android
cinq références mémoires pour chaque instruction Java. En Java est le langage de programmation choisi par Google pour le
conséquence, l’interprétation est de trois à vingt fois plus lente que développement d’une application pour son système Android. Ce
l’exécution du code compilé. Néanmoins, l’espace mémoire alloué système est maintenant largement répandu sur les smart-phones
au code est plus restreint. et tablettes. Dans la chaîne de développement, le compilateur Java
génère les fichiers .class décrits dans le paragraphe 2.1. Ces
Une compilation de type JIT simple consiste à substituer chaque fichiers sont transformés en fichiers .dex et assemblés afin de
appel d’instruction Java par la séquence des opérations fournir une application Android. Ces fichiers .dex sont exécutés par
engendrées extraite de l’interpréteur. Le coût en temps dû à la une machine virtuelle nommée Dalvik Virtual Machine (DVM). La
sélection est évité, mais la taille du code augmente de façon DVM est une machine à registres avec son jeu d’instructions

Instructions Source Java Opérations engendrées

Object obj = new Object () ; {

obj = new Point () ;
String s = [Link] () ;
aload_0 empiler (frame [vars + 0] ) ;
ref = depiler () ;
invokevirtual_quick, 00, 05 typeConstaté (ref) . TMV [5] () ;
// le type déclaré de obj est Object
// le type constaté dans cette portion de
code de obj est Point, Cf. Liaison dynamique
astore_1 frame [vars + 1] = depiler () ;

Figure 22 – Table des méthodes virtuelles

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. H 1 588v2 – 21

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

MACHINE VIRTUELLE JAVA (JVM) ______________________________________________________________________________________________________

5. Conclusion
Connection Windows En quelques années, la diffusion de Java a engendré un nombre
4064@localhost important d’implémentations de la machine virtuelle. Il devient rare
Summary Memory Theards Classes MBeans VM de disposer d’un ordinateur sans une machine virtuelle Java. Dix
Chart : Memory Pool "Tenured Gen" Perform GC
années se sont écoulées depuis la première version de cet article, et
fait assez rare en informatique, la définition du jeu d’instructions et
9.0 Mb
la grammaire des fichiers générés sont restées les mêmes. Le code
Used
6,842,352
intermédiaire assure une stabilité et les millions de machines Java
6.0 Mb Threshold installées dans le monde y contribuent également.
5.0 Mb 6,144,000

21:51 21:52 21:53 21:54 21:55 21:56 21:57 21:58 21:59 22:00 22:01 22:02 Cette machine virtuelle est maintenant présente sur bon nombre
d’ordinateurs allant du serveur d’applications pour de grandes entre-
Details
prises aux clients équipés d’un navigateur. Un autre succès a été le
Time : 2004-11-03 22;02;08 100% portage d’une version minimale de cette machine [7] sur les mobiles
Used : 6,681 kbytes
Committed : 13,088 kbytes
75% que l’on pourrait qualifier de première génération, la machine vir-
Max : 60,544 kbytes 50% tuelle développée par Google pour leur système Android en Java
Usage Threshold : 6,000 kbytes 25%
GC time :0.887 seconds seconds on Copy (402 collections) semble s’imposer sur les smart-phones et autres tablettes. Un autre
6.608 seconds seconds on MarkSweepCompact 0% succès toujours actuel est le portage de cette machine sur une carte
(62 collections)
SIM équipant la plupart des téléphones mobiles.
De nouveaux langages sont apparus : Scala, Groovy, JJRuby,
Jython, Clojure, et le point commun entre ces langages est qu’ils
utilisent la machine virtuelle Java. La dernière version du JDK
Figure 23 – Copie d’écran (doc. Oraclé Technology Network) (Java Development Kit), la JDK7 propose une nouvelle instruction
invokedynamic, générée par une version d’un compilateur pour
JRuby.
approprié. La taille du code généré est supérieure à celui généré
par une machine à pile, ce qui est largement compensée par une La pérennité de l’architecture présentée dans cet article semble
optimisation du fichier .class devenu .dex. assurée au moins pour la prochaine décennie.
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

H 1 588v2 – 22 est strictement interdite. – © Editions T.I.

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

P
O
U
Machine virtuelle Java (JVM) R

E
par Jean-Michel DOUIN
Ingénieur et docteur du CNAM
N
Enseignant/chercheur au CNAM

S
Sources bibliographiques
A
[1] GOSLING (J.), JOY (B.) et STEELE (G.). – The [4] McGRAW (G.). – Java 2’s verifier becomes [Link] V
java language specification. confused by german student’s security at- [Link]

[2]
[Link]
LINDHOLM (T.) et YELLIN (Y.). – The java vir-
tack.
[Link]
[7] K Virtual Machine. White paper.
[Link]
O
tual machine specification. http:// 1999/[Link]

[3]
[Link]/docs/books/vmspec
DYER (D.). – Java decompilers compared.
[5] WILKINSON (T.). – Open source implementa-
tion of a java virtual machine.
I
[Link]
(1997).
[Link]
1997/[Link]
[6] The Java Hotspot performance engine archi-
tecture. White paper.
R
Parution : août 2013 - Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]

Sites Internet
Garbage – First Collector PicoJava et processeurs Java
P
[Link]
Carte à puce Java Sun
[Link]
[Link]
Oracle Technology Network
[Link]
L
U
Annuaire
Fabricants (liste non exhaustive) Oracle
S
[Link]
Dallas Semiconductor
[Link] Organismes
Ajile Systems Standard Performance Evaluation Corporation (SPEC)
[Link] [Link]

Toute reproduction sans autorisation du Centre français d’exploitation du droit de copie

est strictement interdite. – © Editions T.I. Doc. H 1 588v2 – 1

tiwekacontentpdf_h1588 v2 Ce document a ete delivre pour le compte de 7200031372 - nantes universite // [Link]
 L’EXPERTISE TECHNIQUE
& SCIENTIFIQUE DE RÉFÉRENCE

Gagnez du temps et sécurisez vos projets

en utilisant une source actualisée et fiable !

15 DOMAINES D’EXPERTISE

 Automatique - Robotique  Mécanique Articles de référence

disponibles en français
 Biomédical - Pharma  Mesures - Analyses et en anglais

 Construction et travaux publics  Procédés chimie - bio - agro

 Électronique - Photonique  Sciences fondamentales
 Énergies  Technologies de l’information
 Environnement - Sécurité
 Génie industriel
Détails des offres et sommaires
à retrouver sur le site
 Ingénierie des transports
[Link]
 Innovation
 Matériaux

+ de 10 000 articles + de 550 bases Service de Questions

de référence et documentaires, aux experts.
Les offres Techniques de
1 000 fiches pratiques 8 Parcours Pratiques
l’Ingénieur permettent
opérationnelles. répartis dans plus
d’accéder à une base
de 90 offres.
complète et actualisée
d’articles rédigés par les
3 000 quiz 1 280 auteurs Les Archives,
meilleurs experts
dans + de 1 000 contribuent chaque technologies anciennes
et validés par des comités
articles interactifs. année à enrichir et versions antérieures
scientifiques, avec :
cette ressource. des articles.

+ de 300 000 utilisateurs de [Link] chaque mois !

NOS ÉQUIPES SONT Par téléphone Par email

À VOTRE DISPOSITION  33 (0)1 53 35 20 20  [Link]@[Link]

[Link]