Langage machine
Un article de Wikipédia, l'encyclopédie libre.
Le langage machine ou code machine est la suite de bits qui est interprétée par le processeur de l'ordinateur lors de l'exécution d'un programme. C'est le langage natif du processeur, et le seul qui soit reconnu par celui-ci.
Chaque processeur possède son propre langage machine. Si un processeur A est capable d'exécuter toutes les instructions du processeur B, on dit que A est compatible avec B. L'inverse n'est pas forcément vrai, A peut avoir des instructions supplémentaires que B ne connaît pas.
Sommaire |
[modifier] Instructions du langage
Les « mots » d'un langage machine sont appelés instructions. Chacune d'elles déclenche une commande de la part du processeur (par exemple : chercher une valeur dans la mémoire pour charger un registre, additionner deux registres, etc.).
Un processeur à architecture RISC ne reconnaît que peu d'instructions différentes, alors qu'un processeur à architecture CISC en possède un large éventail. Néanmoins certains processeurs CISC récents transforment en interne les instructions complexes en une suite d'instructions simples, qui sont alors exécutées.
Un programme est juste une longue séquence d'instructions qui sont exécutées par le processeur. Elles sont exécutées séquentiellement sauf quand une instruction de saut transfère l'exécution à une autre instruction que celle qui suit. Il existe également des sauts conditionnels qui sont soit exécutés (l'exécution continue à une autre adresse) ou ignorés (l'exécution continue à l'instruction suivante) selon certaines conditions.
[modifier] Opcode
Chaque instruction commence par un numéro appelé opcode ou code opération qui détermine la nature de l'instruction. Par exemple, pour les ordinateurs d'architecture x86, l'opcode 0x6A (en binaire 01101010) correspond à l'instruction push (ajouter une valeur en bas de la pile). Par conséquent, l'instruction 0x6A 0x14 (01101010 00010100) correspond à push 0x14 (ajouter la valeur hexadécimale 0x14 en bas de la pile).
[modifier] Longueur des instructions
Certains processeurs codent toutes leurs instructions avec le même nombre de bits (par exemple : ARM, MIPS, PowerPC), tandis que chez d'autres la longueur de l'instruction dépend de l'opcode (exemple : x86). L'organisation des combinaisons de bits dépend largement du processeur. Le plus commun est la division en champs. Un ou plusieurs champs spécifie l'opération exacte (par exemple une addition). Les autres champs indiquent le type des opérandes, leur localisation, ou une valeur littérale (les opérandes contenus dans une instruction sont appelés immédiat).
[modifier] Avantages et inconvénients
Lorsque toutes les instructions ont la même taille elles sont également alignées en mémoire. Par exemple si toutes les instructions sont alignées sur 32 bits (4 octets), alors les 2 bits de poids faibles de l'adresse mémoire de n'importe quelle instruction sont à zéro. Cela permet notamment une implémentation plus aisée du cache des prédictions de branchement bimodales.
En revanche le code machine prend moins de place en mémoire s'il ne possède pas de taille minimum, étant donné qu'on élimine les champs non utilisés.
[modifier] Ecrire du langage machine
Ecrire directement un programme en langage machine serait long et très fastidieux. À la place, on utilise le langage assembleur, qui est une traduction de chaque groupe de bits de l'instruction. Le langage assembleur est ensuite converti en langage machine grâce à un logiciel appelé assembleur.
Il faut néanmoins garder à l'esprit que de très nombreux langages sont transformés en langage machine lors de la compilation. Tous les programmes exécutables contiennent au moins une petite partie en langage machine.
[modifier] Exemples
[modifier] Processeur MIPS
Comme exemple spécifique, regardons l'architecture MIPS. Ses instructions ont toujours une longueur de 32 bits. Le type général de l'instruction est donné par les 6 bits de poids les plus forts (dans une représentation sur 32 bits, les 6 de gauche), qu'on appelle le champ op.
Les instructions de type-J et de type-I sont pleinement spécifiées par le champ op. Les instructions de type-R ont un champ supplémentaire, fonct, pour déterminer la nature exacte de l'opération. Les champs de ces 3 types d'instructions sont :
6 5 5 5 5 6 bits [ op | rs | rt | rd |shamt| fonct] type-R [ op | rs | rt | adresse/immédiat ] type-I [ op | adresse cible ] type-J
rs, rt, et rd indique des opérandes de type registre ; shamt indique un décalage (shift amount) ; et le champ adresse ou immédiat contient un opérande sous forme de valeur.
Par exemple, ajouter les registres 1 et 2 et placer le résultat dans le registre 6 est codé :
[ op | rs | rt | rd |shamt| fonct]
0 1 2 6 0 32 décimal
000000 00001 00010 00110 00000 100000 binaire
Charger une valeur depuis la cellule mémoire 68 cellules après celle pointée par le registre 3 dans le registre 8 :
[ op | rs | rt | adresse/immédiat ] 35 3 8 68 décimal 100011 00011 01000 000000000001000100 binaire
Sauter à l'adresse 1025 (la prochaine instruction à exécuter se trouve à l'adresse 1025) :
[ op | adresse cible ]
2 1025 décimal
000010 000000000000000000010000000001 binaire
[modifier] Processeur ARM
Les processeurs de l'architecture ARM sont un cas particulier dans la mesure où toutes les instructions sont conditionnelles. Elles sont toutes d'une longueur de 32 bits, et leur 4 premiers bits indiquent dans quelles conditions l'instruction doit être exécutée.
[modifier] Voir aussi
- Langage assembleur dit de deuxième génération
- Langage de haut niveau dit de troisième génération
- L4G ou langage de quatrième génération
- Processeur, la composante qui exécute le langage machine
- Pipeline (informatique)
