Langage machine

Le code machine peut être écrit sous différentes formes :

• En utilisant un certain nombre d'interrupteurs. Cela génère une séquence de 1 et 0, utilisée aux débuts de l'informatique. Depuis les années 1970, il n'est plus utilisé.
• Utilisation d'un éditeur Hex. Cela permet d'utiliser des opcodes au lieu du numéro de la commande.
• Utilisation d'un assembleur. Les langages d'assemblage sont plus simples que les opcodes. Leur syntaxe est plus facile à comprendre que le langage machine mais plus difficile à comprendre que les langages de haut niveau. L'assembleur traduira le code source en code machine par lui-même.
• L'utilisation d'un langage de programmation de haut niveau permet d'utiliser des programmes dont le code est plus facile à lire et à écrire. Ces programmes sont traduits en code machine. La traduction peut se faire en plusieurs étapes. Les programmes Java sont d'abord optimisés en bytecode. Ensuite, il est traduit en langage machine lorsqu'il est utilisé.

Il existe de nombreux types d'instructions que l'on trouve généralement dans un jeu d'instructions :

• Opérations arithmétiques : Addition, soustraction, multiplication, division.
• Opérations logiques : Conjonction, disjonction, négation.
• Opérations agissant sur des bits simples : Déplacement de bits vers la gauche ou vers la droite.
• Opérations agissant sur la mémoire : copie d'une valeur d'un registre à un autre.
• Opérations qui comparent deux valeurs : plus grand que, plus petit que, égal.
• Opérations qui combinent d'autres opérations : ajouter, comparer et copier si elles sont égales à une certaine valeur (comme une seule opération), sauter à un certain point du programme si un registre est à zéro.
• Les opérations qui agissent sur le déroulement des programmes : sautez à une adresse.
• Opérations qui convertissent les types de données : par exemple, convertir un entier de 32 bits en un entier de 64 bits, convertir une valeur en virgule flottante en un entier (par troncature).

De nombreux processeurs modernes utilisent des microcodes pour certaines commandes. Les commandes plus complexes ont tendance à l'utiliser. Cela se fait souvent avec les architectures CISC.

Chaque processeur ou famille de processeurs possède son propre jeu d'instructions. Les instructions sont des modèles de bits qui correspondent aux différentes commandes qui peuvent être données à la machine. Ainsi, le jeu d'instructions est spécifique à une classe de processeurs utilisant (la plupart du temps) la même architecture.

Les nouveaux modèles de processeurs comprennent souvent toutes les instructions d'un prédécesseur et peuvent ajouter des instructions supplémentaires. Parfois, une conception plus récente interrompra ou modifiera la signification d'un code d'instruction (généralement parce qu'il est nécessaire à de nouvelles fins), ce qui affecte la compatibilité du code ; même les processeurs presque entièrement compatibles peuvent présenter un comportement légèrement différent pour certaines instructions, mais cela pose rarement un problème.

Les systèmes peuvent également différer dans d'autres détails, tels que la disposition de la mémoire, les systèmes d'exploitation ou les périphériques. Comme un programme repose normalement sur de tels facteurs, les différents systèmes n'exécuteront généralement pas le même code machine, même si le même type de processeur est utilisé.

La plupart des instructions comportent un ou plusieurs champs opcode. Ils précisent le type d'instruction de base. D'autres champs peuvent donner le type des opérandes, le mode d'adressage, etc. Il peut également y avoir des instructions spéciales qui sont contenues dans l'opcode lui-même. Ces instructions sont appelées "immédiates".

La conception des processeurs peut être différente d'autres façons. Des instructions différentes peuvent avoir des longueurs différentes. Elles peuvent également avoir la même longueur. Le fait que toutes les instructions aient la même longueur peut simplifier la conception.

L'architecture MIPS comporte des instructions de 32 bits de long. Cette section contient des exemples de code. Le type général d'instruction se trouve dans le champ op (opération). Il s'agit des 6 bits les plus élevés. Les instructions de type J (saut) et de type I (immédiat) sont entièrement données par op. Les instructions de type R (registre) comprennent le champ funct. Il détermine l'opération exacte du code. Les champs utilisés dans ces types sont les suivants :

    6       5      5 5 5 5                6 bits [ op | rs | rt | rd |shamt| funct] R-type [ op | rs | rt | adresse/immédiate] I-type [ op | adresse         cible         ] J-type

rs, rt, et rd indiquent les opérandes de registre. shamt donne un montant de décalage. L'adresse ou les champs immédiats contiennent directement un opérande.

Exemple : additionner les registres 1 et 2. Placez le résultat dans le registre 6. Il est codé :

[ op | rs | rt | rd |shamt| funct]      0      1      2      6      0      32      décimal 000000 00001 00010 00110 00000 100000    binaire

Chargez une valeur dans le registre 8. Prenez-la dans la cellule de mémoire 68 cellules après l'emplacement indiqué dans le registre 3 :

[ op | rs | rt | adresse/immédiate]     35      3      8            68            décimal 100011 00011 01000 00000 00001 000100    binaire

Aller à l'adresse 1024 :

[ op |         adresse         cible ]      2                  1024                décimal 000010 00000 00000 00000 00000 10000 000000    binaire

• Système de numération binaire
• Ordinateurs quantiques
• Jeu d'instructions
• Ordinateur à jeu d'instructions réduit