Le processeur n'est pas le seul composant d'un ordinateur, mais est celui qui coordonne les opérations : il interagit avec la mémoire (voir le chapitre ../Copie entre registres et mémoire/) ; et il interagit avec les composants périphériques de la machine (lecteur de disque, timer, contrôleur d'interruptions, ...) par l'intermédiaire des bus auxquels il est connecté.
Il reçoit des interruptions générées par les périphériques requérant son attention pour traiter un évènement (fin d'écriture d'un buffer sur disque, timer écoulé, ...).
Transfert de données avec les périphériques.
Chaque composant périphérique a ses propres registres de configuration et de statut.
Le processeur communique avec eux en utilisant des instructions de transfert spécifiques, utilisant le bus d'adresse et le bus de données.
Cela se déroule comme pour les transferts avec la mémoire, excepté qu'une broche du bus de contrôle permet de distinguer les deux types d'accès.
Sur 8086, le registre "r" est l'accumulateur donc AL ou AX, et le port peut être une constante ou le registre DX.
Exemple :
in al, 0x60
mov dx, 0x3DF
out dx, ax
Ligne "test".
La broche "TEST" du processeur est active à l'état bas.
L'instruction codice_1 provoque la suspension de l'exécution des instructions par le processeur si cette broche est à 0, jusqu'à ce qu'elle repasse à 1.
Cela permet de synchroniser l'exécution avec un évènement externe.
Dans les architectures PC avec coprocesseur (x87) cette instruction permet d'attendre le résultat d'opérations de calculs.
Coprocesseur x87.
Les premiers modèles de la famille de processeurs x86 étaient dépourvus d'instructions pour le calcul avec des nombres en virgule flottante.
Les langages de programmation devaient donc fournir une bibliothèque de fonctions implémentant les calculs en logiciel.
Ces calculs pouvaient aussi être pris en charge matériellement par un coprocesseur (famille x87 : 8087 pour le 8086, 80287 pour le 80286).
Instructions vers le coprocesseur.
Comme son nom l'indique, le coprocesseur fonctionne avec le processeur.
Il regarde les bus d'adresse, de données et de contrôle et voit la lecture des données et des instructions.
Il est connecté aussi à certaines broches du processeur (via le bus de contrôle) lui permettant de distinguer la lecture d'instructions (opcodes) de celles des autres octets d'instruction et celles des données.
L'instruction codice_2 ("ESCape to coprocessor") est suivie d'un code d'opération de deux opérandes.
Le 80x86 décode ces instructions, et si les opérandes sont des pointeurs en mémoire, envoie l'adresse sur le bus d'adresse.
Le bloc mémoire adressé va alors envoyer les données lues sur le bus de données.
Le 80x86 ne fait aucune autre action.
Du point de vue du 80x86 cette instruction semble n'avoir aucun effet, ce qui est réellement le cas si aucun coprocesseur n'est installé.
En revanche le coprocesseur 80x87 voit le code d'opération et les deux opérandes, et a à sa disposition les données lues de la mémoire si besoin.
Le coprocesseur fonctionne de manière asynchrone : si le 80x86 envoie une autre instruction alors qu'un traitement est déjà en cours, elle sera ignorée.
La solution à ce problème est d'utiliser l'instruction codice_1 qui suspend l'exécution des instructions par le 80x86 tant que l'état 0 est présent sur la broche TEST, celle-ci étant connectée à la broche BUSY du 80x87 que celui-ci utilise pour indiquer qu'une opération est en cours.
Une autre solution consiste à exécuter d'autres instructions pour laisser du temps au coprocesseur (programmation parallèle).

Programmation Assembleur/x86/Opérations arithmétiques et logiques

Opérandes et résultat.
Les opérations arithmétiques et logiques agissent sur un ou deux opérandes.
Il peut s'agir d'un registre, d'un pointeur mémoire ou d'une valeur littérale.
Le premier opérande sert également à stocker le résultat, et ne peut donc pas être une valeur littérale.
Exemples :
add ax, bx ; Ajouter BX à AX
sub word ptr[bx], ax ; Soustraire AX du mot de 16 bits pointé par BX
Opérations arithmétiques.
Les instructions du tableau ci-dessous effectuent une opération arithmétique utilisant deux opérandes représentés ci-dessous par les lettres "x" et "y".
Les instructions de multiplication et division utilisent l'accumulateur (registre AX) comme premier opérande implicitement, seul le deuxième est spécifié.
Leurs résultats étant plus grand que le nombre de bits d'entrée, sont stockés dans les registres AX et DX si besoin.
Ces instructions se distinguent par l'interprétation des nombres en signés (préfixe I comme Integer) et non signé (pas de préfixe) car contrairement aux autres opérations, les résultats diffèrent complètement selon cette interprétation.
Les instructions de la division calculent à la fois le quotient et le reste de la division en une seule opération, et peuvent déclencher une interruption si le second opérande vaut zéro.
Les indicateurs sont mis à jour selon le résultat.
Les instructions du tableau ci-dessous effectuent une opération arithmétique utilisant un seul opérande :
Les indicateurs sont également mis à jour selon le résultat de ces opérations.
Cela permet notamment pour les instructions codice_1 et codice_2 de pouvoir enchaîner avec une instruction de saut conditionnel codice_3 ou codice_4 selon que le résultat est zéro ou différent de zéro afin de réaliser une boucle de répétition pour continuer à l'itération suivante ou sortir de la boucle.
Comparaison et test de bits.
L'instruction codice_5 compare les deux opérandes numériques.
Il s'agit en fait de la même opération que la soustraction de l'instruction codice_6 excepté que le résultat n'est pas stocké.
L'instruction codice_5 ne fait que mettre à jour les indicateurs.
Elle est utilisée juste avant un ou plusieurs sauts conditionnels.
L'instruction codice_8 teste les bits des deux opérandes numériques.
Il s'agit en fait de la même opération que le et logique de l'instruction codice_9 excepté que le résultat n'est pas stocké.
L'instruction codice_8 ne fait que mettre à jour les indicateurs.
Elle est utilisée juste avant un ou plusieurs sauts conditionnels.
Opérations logiques.
Les instructions du tableau ci-dessous effectuent une opération logique utilisant deux opérandes représentés ci-dessous par les lettres "x" et "y".
L'instruction codice_11 du tableau ci-dessous est la seule effectuent une opération logique utilisant un seul opérande :
Les instructions de décalage et de rotation de bits sont listées ci-dessous.
Les premiers modèles de la famille de processeur x86 limitent les possibilités pour le second opérande spécifiant le nombre de positions de décalage :
Ajustements des calculs en BCD.
Le (DCB) ou "binary coded decimal (BCD)" en anglais, est un système de numération où les nombres sont représentés par les chiffres décimaux les composant, chacun codé sur quatre bits.
Un octet permet donc de stocker un nombre décimal à 2 chiffres en DCB, de 0x00 à 0x99.
Le 80x86 permet d'effectuer des calculs dans ce mode, en utilisant les opérations arithmétiques normales puis en utilisant des instructions spéciales pour ajuster le résultat.
Ces instructions n'ont pas d'opérande explicite.
Le codage des instructions codice_12 et codice_13 inclut la base 10 comme second octet, et peut donc être changé pour faire l'opération pour une autre base.
Certains assembleurs permettent de spécifier une autre base comme opérande de ces instructions.
Sinon il est possible de modifier manuellement la base utilisée.
Pour l'instruction codice_12 si la base spécifiée est 0, une interruption Division Overflow est déclenchée.

Programmation Assembleur/x86/Opération
 } 
Programmation UML/Version imprimable
Le langage SGML/Version imprimable
Méthodes de génie logiciel avec Ada/Version imprimable