Accueil Nos publications Blog JVM Hardcore – Part 16 – Bytecode – Comparaisons et contrôle – 1/3

Java

24/02/2014 4 min

JVM Hardcore – Part 16 – Bytecode – Comparaisons et contrôle – 1/3

La possibilité d’avoir des chemins alternatifs ou des boucles sont des éléments indispensables à tout langage de programmation et programme. Au cours de cet article nous étudierons une première série d’instructions permettant de faire des comparaisons.

Le code est disponible sur Github (tag et branche)

Tous les articles déjà publiés de la série portent le tag jvmhardcore.

Représentation de la pile (Rappel)

La JVM étant basée sur le modèle de la pile, il est essentiel de connaître quel est l’impact des instructions. Pour représenter l’état avant/après l’exécution d’une instruction, nous allons reprendre le format utiliser par la JVMS et qui est le suivant :

..., valeur1, valeur2 → ..., résultat, où les valeurs les plus à droite sont au sommet de la pile. valeur1 et valeur2 étant les deux valeurs utilisées pour le calcul et résultat le résultat.

Il est important de noter que dans cette représentation les long et les double sont considérés comme une seule valeur. Par conséquent, lorsque nécessaire nous présenterons les différents cas d’utilisation d’une instruction en utilisant plusieurs formes.

Comparer un nombre de type int à zéro

Les six instructions if<cond> permettent d’effectuer des comparaisons entre une valeur de type int et 0.

État de la pile avant → après exécution : ..., v → ... où v représente la valeur comparée à 0, avec 0 toujours à droite dans la comparaison (v op 0, où op est un opérateur relationnel).

En plus d’une opérande, ces instructions prennent en argument un nombre signé de deux octets dont la valeur est comprise dans l’intervalle [-32768 ; 32767], représentant l’offset de l’instruction à exécuter si la comparaison est vraie. Cet offset est égal à l’adresse de l’instruction à exécuter, à laquelle nous soustrayons l’adresse de l’instruction de comparaison.

Pour clarifier la valeur de l’offset voyons ce que génère la classe HexDumper (seulement les instructions d’une méthode sont présentées ici) :

// ...
0082          0  iload_0
0083          1  iflt <5>
0086          4  iconst_1
0087          5  ireturn
0088          6  iconst_0
0089          7  ireturn
// ...

Pour rappel, la colonne de gauche est l’offset (en octets affiché sous forme hexadécimale) de l’élément. Dans le cas présent, l’élément est une instruction dont l’offset indique sa position dans la totalité d’un fichier .class. La colonne de droite représente l’instruction. La valeur encadrée par le symbole en diamant (<>) est l’offset de débranchement de l’instruction iflt si elle retourne vrai. La colonne du milieu a été ajoutée pour indiquer l’offset (en octets affiché sous forme décimale) d’une instruction dans une méthode.

L’instruction iflt <5> signifie que si la comparaison x < 0 (où la valeur de x est à l’index 0 des variables locales) est vraie alors nous débranchons vers l’instruction se trouvant 5 octets plus loin. L’instruction étant à l’offset 1, si nous ajoutons 5 nous devons exécuter l’instruction se trouvant à l’adresse 6 de la méthode si la comparaison retourne vraie. En d’autres termes, l’instruction iconst_0.

Le code ci-dessus peut être décompilé en Java de la manière suivante :

if (x < 0) {
  return 0;
} else {
  return 1; 
}

Voyons à présent l’ensemble des six instructions, qui reprennent les six opérateurs rationnels que nous avons en Java (<, <=, >, >=, ==, !=).

Hex	Mnémonique	Argument	Description
`0x99`	`ifeq`	`offset`	Va à l’`offset` si `x == 0`, où `x` est de type `int`
`0x9a`	`ifne`	`offset`	Va à l’`offset` si `x != 0`, où `x` est de type `int`
`0x9b`	`iflt`	`offset`	Va à l’`offset` si `x < 0`, où `x` est de type `int`
`0x9c`	`ifge`	`offset`	Va à l’`offset` si `x >= 0`, où `x` est de type `int`
`0x9d`	`ifgt`	`offset`	Va à l’`offset` si `x > 0`, où `x` est de type `int`
`0x9e`	`ifle`	`offset`	Va à l’`offset` si `x <= 0`, où `x` est de type `int`

Exemples

Pour utiliser simplement ces instructions dans un fichier .pjb, nous allons remplacer l’offset par un label. Ce label sera utilisé à la fois en argument de l’instruction mais aussi juste avant l’instruction à exécuter en cas de débranchement, en le faisant suivre par deux-points (‘:’) pour ne pas le confondre avec une instruction.

La grammaire EBNF d’un label est la suivante :

label = labelAsArg labelEnd
labelAsArg = {labelCharacter}
labelEnd = ':'
labelCharacter = ?[a-zA-Z]? | ?[0-9]? | '_'

Un label peut contenir des lettres ASCII (majuscules et minuscules), des chiffres et le caractère souligné (‘_’), par exemple label_1, et doit se terminer par le caractère deux-points (‘:’). Le symbole labelAsArg est la forme d’un label utilisable en tant qu’argument d’une instruction. Le concept de label est uniquement d’une aide pour écrire du code PJB, il n’est aucunement lié au bytecode et à la JVM. Les caractères composant un label peuvent être changés en modifiant le code de PJBA.

iload_0
ifeq ko     @ si a == 0 nous allons à l'instruction 
            @   suivant le label "ko:"
iconst_1    @ sinon nous retournons 1
ireturn
ko:
iconst_0
ireturn     @ nous retournons 0

Comparaisons

Ce bout de code peut être traduit en Java de la manière suivante :

if (a != 0) {
  return 1;
} else {
  return 0;
}

Pour que notre builder soit aussi simple à utiliser nous devons aussi introduire la notion de label dans PJBA.

builder.newMethod(Method.MODIFIER_PUBLIC 
                | Method.MODIFIER_STATIC, "test", "(I)I")
  .iload_0()
  .ifeq("ko")
  .iconst_1()
  .ireturn()
  .label("ko")  // Attention, ici le label ne doit
                // pas être suivi des deux-points
  .iconst_0()
  .ireturn()

Comme nous l’avons déjà vu, la JVM interprète le type boolean comme un int où false == 0 et true == 1. Par conséquent, les instructions que nous avons vues sont utilisables avec des int et des boolean, mais aussi avec des byte, des short et des char.

@ return a == 0; 
@ ou
@ return a == true;
@ où a est à l'index 0 des variables locales
.method public static ifeq(Z)Z
  iload_0
  ifeq ko
  iconst_1
  ireturn
  ko:
  iconst_0
  ireturn
.methodend

Hex	Mnémonique	Argument	Description
`0x9f`	`if_icmpeq`	`offset`	Va à l’`offset` si `v1 == v2`
`0xa0`	`if_icmpne`	`offset`	Va à l’`offset` si `v1 != v2`
`0xa1`	`if_icmplt`	`offset`	Va à l’`offset` si `v1 < v2`
`0xa2`	`if_icmpge`	`offset`	Va à l’`offset` si `v1 >= v2`
`0xa3`	`if_icmpgt`	`offset`	Va à l’`offset` si `v1 > v2`
`0xa4`	`if_icmple`	`offset`	Va à l’`offset` si `v1 <= v2`

Hex	Mnémonique	Argument	Description
`0x94`	`lcmp`	–	Compare deux valeurs de type `long`
`0x95`	`fcmpl`	–	Compare deux valeurs de type `float`
`0x96`	`fcmpg`	–	Compare deux valeurs de type `float`
`0x97`	`dcmpl`	–	Compare deux valeurs de type `double`
`0x98`	`dcmpg`	–	Compare deux valeurs de type `double`

Comparaison	Instructions suivi du label
Comparaison	ko	ok
`a < b`	`ifge`	`iflt`
`a <= b`	`ifgt`	`ifle`
`a == b`	`ifne`	`ifeq`
`a != b`	`ifeq`	`ifne`
`a > b`	`ifle`	`ifgt`
`a >= b`	`iflt`	`ifge`

Néosoft rejoint le réseau de partenaires AWS

JVM Hardcore – Part 16 – Bytecode – Comparaisons et contrôle – 1/3

Représentation de la pile (Rappel)

Comparer un nombre de type int à zéro

Exemples

Comparaisons

Boucles

Comparer des nombres de type int

Comparer des nombres de type long, float et double

What’s next ?