Bytecode

Fichier:Binario cropped.png

Code binaire

Modèle:Langue du titre En informatique, le Modèle:Langue (terme anglais signifiant « code en bytes ») est un code intermédiaire entre les instructions machines et le code source, qui n'est pas directement exécutable. Le Modèle:Langue (également appelé code portable ou p-code) peut être créé à la volée et résider en mémoire (compilation à la volée, JIT en anglais) ou bien résider dans un fichier, généralement binaire qui représente le programme, tout comme un fichier de code objet produit par un compilateur.

Puisque c'est un code qui n'est pas exécutable directement par un processeur (à l'exception de certains processeurs gérant le [[Bytecode Java|Modèle:Langue Java]] nativement), il est utilisé par les créateurs de langages de programmation en guise de code intermédiaire réduisant la dépendance vis-à-vis du matériel et facilitant son interprétation sur plusieurs architectures.

Certains compilateurs, comme LLVM, et langages de scripts, comme SmallTalk, Java ou certaines implémentations de Ruby (telles que JRuby, Ruby.NET ou SmallRuby), utilisent le Modèle:Langue comme représentation intermédiaire avant la transformation en code machine vers l'architecture cible (x86, ARM, MIPS, etc.).

Certains systèmes, appelés « traducteurs dynamiques » ou « compilateurs à la volée » (Modèle:Langue en anglais), traduisent le Modèle:Langue en code machine au fur et à mesure de l’exécution, cela permet d’accélérer l’exécution sur les boucles ou les fonctions appelées plusieurs fois tout en évitant de stocker sur disque ou de transférer via les réseaux des données précompilées. Cette technique est notamment utilisée dans le langage Java et dans les émulateurs de systèmes (ordinateurs ou consoles de jeu par exemple), retranscrivant les instructions d'un langage machine à un autre et plus généralement d'une architecture matérielle à une autre.

Un programme à base de Modèle:Langue est exécuté par un interpréteur appelé machine virtuelle, car elle exécute le code tout comme un microprocesseur. L'avantage est la portabilité : le même Modèle:Langue peut être exécuté sur diverses plates-formes ou architectures pour lesquelles un interpréteur existe. Un programme sous forme de Modèle:Langue peut donc être transmis d'une machine à une autre, et être interprété puis exécuté sans modification de celui-ci par différents types d'architectures matérielles. L'avantage est le même que pour les scripts, qui sont directement interprétés (et non compilés en Modèle:Langue). Cependant, le Modèle:Langue est plus concret, plus compact et plus facile à manipuler qu'un script, prévu pour être intelligible par l'homme. Pour ces raisons, les performances des interpréteurs de Modèle:Langue sont généralement bien meilleures que celles des interpréteurs de scripts.

Pour bénéficier de ces avantages, aujourd'hui de nombreux langages interprétés sont en fait compilés en Modèle:Langue avant d'être exécutés par un interpréteur. C'est le cas par exemple de PHP (lorsqu'il est utilisé pour des applications), de Tcl, de Python. Un programme Java est habituellement transmis sous forme de Modèle:Langue à une machine hôte qui utilisera une compilation à la volée pour traduire le Modèle:Langue en code machine avant exécution. Les implémentations actuelles de Perl et de Ruby utilisent non pas du Modèle:Langue, mais une structure en arbre qui se rapproche de la représentation intermédiaire des compilateurs.

Les p-codes diffèrent des Modèle:Langue par le codage de leurs opérations, qui peut être de plusieurs octets avec une taille variable, tout comme les opcodes de nombreux processeurs. Ils ont un plus haut niveau descriptif, comme « afficher cette chaine de caractères » ou encore « effacer l'écran ». Le BASIC et quelques versions de Pascal utilisent un p-code.

Exemples

• O-code de BCPL ;
• CLISP, une implantation de Common Lisp, ne compile qu'en Modèle:Langue ;
• CMUCL, une implantation de Common Lisp, peut compiler en Modèle:Langue ou en code natif ; le code natif est bien plus compact ;
• OCaml peut compiler un Modèle:Langue compact, mais pas seulement ; le Modèle:Langue d'OCaml et son interpréteur (Modèle:Langue) semblent former l'une des combinaisons les plus efficaces Modèle:Référence nécessaire parmi tous les Modèle:Langue existants ;
• Microsoft .NET Common Intermediate Language, exécuté par le Common Language Runtime ;
• Java de Sun Microsystems (voir Bytecode Java) ;
• Python, où un module (fichier module.py) est compilé vers du Modèle:Langue (fichier module.pyc) à l'importation durant l'exécution, mais pas nécessairement à l'exécution ;

<syntaxhighlight lang="python"> >>> import dis #"dis" - Disassembler of Python byte code into mnemonics. >>> dis.dis('print("Hello, World!")')

 1           0 LOAD_NAME                0 (print)
             2 LOAD_CONST               0 ('Hello, World!')
             4 CALL_FUNCTION            1
             6 RETURN_VALUE

</syntaxhighlight>

• Le SPIN du Propeller de Parallax Inc.