Tutoriel illustré sur Assembleur. Instructions arithmétiques d'assemblage
Équipe CDA(Ajouter avec Carry) appartient au groupe commandes entières(ou binaire)arithmétique (Instructions arithmétiques binaires) et effectue l'addition entière de deux opérandes signés ou non signés ( DEST Et SRC) Et porter le drapeau EFLAGS.CF . Premier opérande ( opérande de destination, DEST) peut être une variable dans un registre ou en mémoire ( , r16, r32 , r/m8, r/m16, r/m32). Deuxième opérande ( opérande source, SRC) - sens immédiat ( imm8, imm16, imm32), une variable dans un registre ou en mémoire. Dans ce cas, les deux opérandes ne peuvent pas être simultanément des variables en mémoire.
Résultat de l'ajout par commande CDA est placé à la place du premier opérande ( DEST). Les drapeaux du registre EFLAGS sont définis en fonction du résultat.
Lors de l'ajout d'une valeur directe imm8 ou imm16 avec un opérande de deux ou quatre octets, la valeur immédiate est d'abord étendue par signe jusqu'à la taille du premier opérande, et ensuite seulement l'addition est effectuée.
Équipe CDA généralement utilisé en multioctet ou multimot ( multi-mot) opérations d'addition. Dans ce cas, elle suit l'instruction ADD, qui renvoie la somme des bits de poids faible des opérandes multioctets (multi-mots), permettant de prendre en compte la retenue lors de l'addition des bits de poids fort. Par exemple:
déplacer edx, 0 ; EDX = 0
mov eax, 0FFFFFFFFh ; Le premier addend 32 bits est placé dans EAX
ajouter eax, 0FFFFFFFFh ; deuxième ajout 32 bits - 0x FFFFFFFFh, on ajoute deux opérandes 32 bits
adc edx, 0 ; EDX = EDX + CF, prendre en compte le report
; EDX:EAX = 0000000lh:FFFFFFFEh - le résultat 64 bits résultant
Équipe CDA permet la manipulation d'opérandes entiers comme dans format non signé, et en format signé. Lors de l'ajout de données avec un signe signer un drapeau EFLAGS.SF reflétera le signe du résultat obtenu. Indicateur de débordement EFLAGS.OF sera mis à 1 si, lors de l'ajout de valeurs entières signées représentées en complément à deux ou en complément à deux, un débordement se produit (portant du bit de poids fort auquel correspond le bit précédant le bit de signe), c'est-à-dire le le résultat obtenu dépasse la taille disponible de l'opérande -rendements ( DEST). Essentiellement, cela est similaire à la façon dont l'indicateur EFLAGS.CF reflète le débordement (carry) lors de l'ajout opérandes non signés. Par exemple, lors de l'ajout de deux valeurs 32 bits représentées en code inversé, cela pourrait ressembler à ceci :
mov eax, opérande1 ; EAX = opérande1, le premier addend de 32 bits est placé dans EAX
ajouter eax, opérande2 ; on ajoute deux opérandes de 32 bits en code inverse
dans ; passer au gestionnaire d'interruption en cas de débordement
adc eax, 0 ; EAX = EAX + CF, prendre en compte le report (nécessaire pour l'addition en code inversé)
; EAX = opérande1 + opérande2 - le résultat de l'addition en code inverse
jns m1 ; transition si le résultat est positif
xor eax, 7FFFFFFFh ; conversion d'une valeur négative dans EAX en code simple
m1 : ; EAX - le résultat de l'ajout en code direct
Drapeau auxiliaire(ou supplémentaire)transfert EFLAGS.AF permet de manipuler les données au format BCD ( format BCD compressé). Il est défini si, lors de l'addition, un report se produit de la tétrade basse à la tétrade haute de l'octet de poids faible du résultat. Utilisation de la commande DAA immédiatement après la commande CDA, il est possible de produire ce qu'on appelle correction décimale le résultat de l'addition et obtenir la somme de la même manière format BCD emballé, comme les termes originaux.
Équipe CDA avec l'opérande de destination ( DEST), qui est une variable mémoire, peut être utilisée conjointement avec le préfixe de verrouillage LOCK, qui assurera l'exécution atomique de la commande.
Commandes d'addition - ADD, ADC
Les instructions ADD (ajouter) et ADC (ajouter avec report) peuvent ajouter des opérandes de 8 et 16 bits.
L'instruction ADD ajoute le contenu de l'opérande source et de l'opérande de destination et place le résultat dans l'opérande de destination.
Format de commande : AJOUTER un récepteur, une source
En notation symbolique, ses actions peuvent être décrites comme suit : puits := puits + source (la somme du contenu du puits et de la source est écrite dans le puits).
La commande ADC fait la même chose que la commande ADD, mais ajoute non pas deux, mais trois termes : la destination, la source et l'indicateur de retenue.
Format de commande : Récepteur ADC, source + CF
En notation symbolique, ses actions peuvent être décrites comme suit :
puits := puits + source + contenu de l'indicateur de transport.
Le report lors de l'ajout de nombres binaires est similaire au report lors de l'ajout de nombres décimaux dans une colonne. Lorsque l'ordinateur ajoute des nombres binaires et que la somme ne rentre pas dans l'opérande de destination, un report est généré. Comme vous le savez, un registre de 8 bits peut contenir des valeurs non signées comprises entre 0 et 255. Si nous effectuons par exemple l'addition binaire des nombres 250 et 10, nous obtiendrons le résultat suivant :
1111 1010 ; représentation binaire du nombre 250.
0000 1010 ; représentation binaire du nombre 10.
1 0000 0100 ; représentation binaire de la somme égale à 260.
Le résultat est correct, mais occupe 9 bits binaires. Si des registres de 8 bits ont été utilisés, alors les 8 bits inférieurs seront entrés dans le registre de destination et le neuvième bit dans l'indicateur de retenue CF.
Nous comprenons maintenant pourquoi le microprocesseur 8086 possède deux instructions d'addition différentes. L'un d'eux (ADD) peut ajouter des valeurs représentées par des octets ou des mots, ainsi que les parties inférieures de valeurs de haute précision. Une autre instruction (ADC) est utilisée pour ajouter des valeurs de haute précision.
Les opérandes à ajouter peuvent être en mémoire, dans un registre ou avoir une valeur immédiate. Par exemple:
AJOUTER AX,MEM_WORD ; ajouter le contenu d'une cellule mémoire dans un registre,
AJOUTER MEM_WORD,AX; ou vice versa, ajoutez le contenu du registre à la cellule mémoire.
AJOUTER AL, 10 ; ajouter une constante au contenu du registre.
AJOUTER MEM_BYTE,8H ; ajoutez la constante et le contenu de la cellule mémoire.
La plupart des combinaisons possibles sont autorisées, mais c'est interdit ajoutez le contenu de deux cellules mémoire ou utilisez une valeur directe (nombre) comme récepteur.
Les commandes ADD et ADC peuvent affecter les six indicateurs suivants :
porter le drapeau CF vaut 1 si le résultat de l'addition ne rentre pas dans l'opérande de destination, sinon il vaut 0 ;
drapeau de parité PF vaut 1 si le résultat a un nombre pair de bits avec la valeur 1, sinon il vaut 0 ;
AF est égal à 1 si le résultat de l'ajout de nombres décimaux nécessite une correction ;
zéro drapeau ZF vaut 1 si le résultat est 0 ;
signer un drapeau SF vaut 1 si le résultat est négatif (le bit de poids fort vaut 1), sinon il vaut 0 ;
drapeau de débordement OF est égal à 1 si la somme de deux nombres du même signe dépasse la plage des valeurs acceptables du récepteur dans le code inverse, et que le récepteur lui-même change de signe. Sinon, le drapeau OF est 0.
Commande pour augmenter la valeur du récepteur de un - INC
Équipe INC.(incrément) ajoute 1 au contenu d'un registre ou d'une cellule mémoire, mais contrairement à l'instruction ADD, il n'affecte pas le drapeau de report CF. Format de commande : Récepteur INC.
L'instruction INC est utile pour incrémenter les compteurs dans les boucles d'instructions. Il peut également être utilisé pour augmenter la valeur du registre d'index lors de l'accès à des cellules mémoire séquentielles. L'opérande est interprété comme un nombre non signé.
Par exemple:
INC CX ; augmenter la valeur de 16 bits
INC AL; ou registre 8 bits par unité.
INC MEM_BYTE ; augmenter la valeur de l'octet
INC MEM_WORD ; ou mots mémoire par unité.
Il n'est pas permis d'utiliser une valeur immédiate comme opérande.
Commandes de soustraction - SUB et soustraction avec emprunt CFF
Équipes SOUS(soustraire - soustraire) et CFF(soustraire avec emprunter) sont similaires aux commandes d'addition ADD et ADC, respectivement, uniquement lors de la soustraction, le drapeau de report CF agit comme le signe d'un prêt. Format de commande : Récepteur SUB, source ;
La commande SUB soustrait l'opérande source de l'opérande de destination et place le résultat dans la destination, en notation symbolique :
puits := puits – source.
Équipe CFF fait la même chose, mais soustrait en plus la valeur du drapeau de transport CF du récepteur :
Récepteur SUB, source – CF ;
Destination := puits - source - contenu de l'indicateur de report.
Comme pour l'addition, les instructions SUB et SBB remplissent deux fonctions distinctes. La première commande soustrait les nombres de taille octet ou mot, ainsi que les bits de poids faible des nombres de haute précision (la partie de poids faible du nombre est située dans le registre AX et la partie de poids fort dans le registre DX). La deuxième commande soustrait les bits les plus significatifs des nombres de haute précision. Par exemple, la commande SUB AX,CX; Soustrait le contenu du registre CX du contenu du registre AX et renvoie le résultat au registre AX.
Si la taille des opérandes dépasse 16 bits, la séquence de commandes suivante doit être utilisée :
SOUS-AXE, CX ; Soustraire les 16 bits faibles ;
CFF BX,DX; puis les 16 bits les plus significatifs.
Ici, nous soustrayons du nombre 32 bits placé dans les registres AX et BX le nombre 32 bits situé dans les registres CX et DX. Lors de la soustraction du contenu du registre DX du contenu du registre BX, l'instruction SBB prend en compte la possibilité d'emprunter lors de la première soustraction.
SOUS-AXE, MEM; Soustrayez le contenu d’une cellule mémoire d’un registre.
SOUS-MEM,AX; Soustraire un registre d'une cellule mémoire.
SOUS-AL,1O ; Soustraire une constante d'un registre.
SUB MEM_BYTE,OFh ; Soustrayez une constante d’une cellule mémoire.
Impossible de soustraire directement le contenu d'une cellule mémoire d'une autre, ou utiliser la valeur immédiate comme destination.
Les commandes SUB et SBB peuvent affecter six flags comme suit :
· installer porter le drapeau CF vaut 1 si un prêt est requis, sinon il vaut 0 ;
· installer drapeau de parité PF vaut 1 si le résultat de la soustraction a un nombre pair de bits valant 1, sinon il vaut 0 ;
· installer drapeau de transport auxiliaire AF vaut 1 si le résultat de la soustraction décimale nécessite une correction, sinon il vaut 0 ;
· installer zéro drapeau ZF à 1 si le résultat est 0, sinon il vaut 0 ;
· installer signer un drapeau SF vaut 1 si le résultat est négatif (le bit de poids fort vaut 1), sinon le flag vaut 0 ;
· installer drapeau de débordement OF vaut 1 si le résultat de la soustraction dépasse la plage des valeurs du récepteur dans le code inverse et que le récepteur lui-même change de signe.
Les indicateurs SF et OF n'ont de sens que lors de la soustraction de nombres signés, et l'indicateur AF n'a de sens que lors de la soustraction de nombres décimaux.
Commande Diminuer le contenu de la destination - DEC
Équipe Récepteur DEC(décrémentation) soustrait 1 du contenu d'un registre ou d'un emplacement mémoire, mais (contrairement à l'instruction SUB) n'affecte pas l'indicateur de report CF.
L'instruction DEC est souvent utilisée dans des boucles pour décrémenter une valeur de compteur jusqu'à ce qu'elle devienne nulle ou négative. Il peut également être utilisé pour décrémenter la valeur d'un registre d'index ou d'un pointeur lors de l'accès à des emplacements mémoire séquentiels. Par exemple:
DÉC CX ; Diminuer la valeur 16 bits,
DÉC AL ; ou registre 8 bits.
DEC MEM_BYTE ; Diminuer la valeur de l'octet,
DEC MEM_WORD ; ou cellule mémoire de mots.
Commandes de division - DIV, IDIV
Équipe DIV(diviser - diviser) effectue une division non signée des nombres et la commande IDIV(division entière - diviser des entiers) effectue une division signée des nombres. Ces commandes ont le format :
Source DIV; Où source- diviseur de taille d'octet ou de mot,
Source IDIV;situé dans un registre à usage général ou un emplacement mémoire.
Veuillez noter ce qui suit :
1. Le dividende doit être double par rapport au diviseur.
2. Le dividende doit toujours être dans le registre AX (lors d'une division par un nombre de 8 bits) ou dans les registres DX et AX (lors d'une division par un nombre de 16 bits).
3. Les résultats de la commande sont renvoyés comme suit :
· si l'opérande source est un octet, alors le quotient est renvoyé au registre AL et le reste au registre AN ;
· Si l'opérande source est un mot, alors le quotient est renvoyé au registre AX et le reste au registre DX.
Les deux instructions laissent l'état des drapeaux indéfini, mais si le quotient ne rentre pas dans le registre de destination (AL ou AX), alors le microprocesseur génère une interruption de type 0 (division par 0).
4. Le débordement du résultat de la division se produit dans les conditions suivantes :
· le diviseur est 0 ;
· lors de la division d'octets sans signe, le dividende est au moins 256 fois le diviseur ;
· lors de la division de mots sans signe, le dividende est d'au moins 65 536 fois le diviseur ;
· lors de la division d'octets par un signe, le quotient se situe en dehors de la plage -128 à +127 ;
· lors de la division de mots par un signe, le quotient se situe en dehors de l'intervalle allant de
32768 à 32767.
Voici quelques exemples typiques d’opérations de division :
DIVBX ; Divisez DX:AX par BX, non signé.
DIVMEM_BYTE ; Divisez AX en un octet de mémoire, non signé.
IDIVDL ; Divisez AX par DL avec un signe.
MOT IDIV MEM ; Divisez DX:AX en un mot mémoire signé.
Les instructions DIV et IDIV ne divisent pas directement par la valeur immédiate car le processeur ne peut pas déterminer le type de données du diviseur.
Instructions de multiplication - MUL, IMUL
Équipe MUL(multiplier) multiplie les nombres non signés, un IMUL(multiplication entière) multiplie les entiers signés. Le multiplicande et le multiplicateur des deux instructions doivent être du même type de données, c'est-à-dire octets, mots, mots doubles, etc.
Ces commandes ont le format suivant :
Source MUL; Où source- registre à usage général,
Source IMUL; ou une cellule mémoire de la taille d'un octet ou d'un mot.
Comme premier opérande (multiplicable), les instructions MUL et IMUL utilisent le contenu du registre AL (pour les opérations sur les octets) ou du registre AX (pour les opérations sur les mots). Le produit a une taille double et est retourné comme suit :
· multiplier octets-renvoie le produit 16 bits dans les registres AN (octet de poids fort) et AL (octet de poids faible) ;
· multiplier mots-renvoie le produit 32 bits dans les registres DX (mot haut) et AX (mot bas). Ainsi, la taille du produit n- les facteurs de bits sont égaux 2n.
ADC Addition entière avec report
Équipe adc effectue l'addition du premier et du deuxième opérande, en ajoutant la valeur de l'indicateur de report CF au résultat. La valeur originale du premier opérande (destination) est perdue, remplacée par le résultat de l'addition. Le deuxième opérande est inchangé. Comme premier opérande de la commande adc
Les opérandes peuvent être des octets ou des mots et représenter des nombres signés ou non signés. Équipe adc(avec l'équipe ajouter) est généralement utilisé pour ajouter des nombres 32 bits. La commande affecte les flags OF, SF, ZF, AF, PF et CF.
Exemple 1:
Mouvement AX,1125h adc AX,2C25h ; AX=3D4Bh, si CF était = 1;AX=3D4Ah, si CF était = 0
Exemple 2:
; Dans les champs de données : numlow dw 0FFFFh ; La partie basse du 2ème terme numhigh dw 000Sh ; La partie la plus élevée du 2ème trimestre ;Numéro 0005FFFFh=393215 ;Dans le segment de programme : mov AX,000Sh ; Partie d'ordre inférieur du 1er terme mov BX,0002h ; La partie la plus élevée du 1er terme ;Numéro 00020005h=131077 ajouter AX,numlow ; Ajout de parties juniors. AX=4, CF=1 adc BX, numhigh ; Ajout de parties supérieures avec portage. BX:AX=0008:0004h. ;Numéro 00080004h=524292
L'utilisation d'opérandes 32 bits et de modes d'adressage supplémentaires de processeurs 32 bits est acceptable. Équipe adc avec des opérandes de 32 bits, peut être utilisé pour ajouter des entiers de 64 bits.
Exemple:
; Dans les champs de données mem321 dd 0FFFFFFFFh ; Partie d'ordre inférieur du 1er terme mem32h dd 98765432h ; La partie la plus élevée du 1er mandat ; Dans le segment de programme mov EAX,1 ; Partie d'ordre inférieur du 2ème terme mov EBX,0 ; La partie la plus élevée du 2ème terme ajoute EAX,mem321 ; Ajoutez les moitiés inférieures ; Somme = 100000000h>32 bits ; EAX = 000000h, reportez adc EBX, mem32h ; Pliez les moitiés les plus anciennes et conservez-les. EBX=90000001h ; Montant : 9876543300000000h
AJOUTER Addition entière
Équipe ajouter effectue l'addition du premier et du deuxième opérande. La valeur originale du premier opérande (destination) est perdue, remplacée par le résultat de l'addition. Le deuxième opérande est inchangé. Comme premier opérande de la commande ajouter Vous pouvez spécifier un registre (sauf celui d'un segment) ou une cellule mémoire, le second peut être un registre (sauf celui d'un segment), une cellule mémoire ou une valeur immédiate, mais il n'est pas permis de définir simultanément les deux opérandes comme mémoire. cellules.
Les opérandes peuvent être des octets ou des mots et représenter des nombres signés ou non signés. La commande add peut être utilisée pour ajouter à la fois des entiers réguliers et des nombres décimaux binaires (en utilisant le registre AX pour stocker le résultat). Si des nombres décimaux codés binaires (BCD) décompressés sont ajoutés, après la commande ajouter la commande aaa doit être utilisée ; si des nombres compressés sont ajoutés, alors la commande Ouais. La commande affecte les flags OF, SF, ZF, AF, PF et CF.
Exemple 1:
Mov BX,lFFEh mov CX,3 ajouter BX,CX ; BX=2001h, CX=0003h
Exemple 2:
Mouvement AX,25h ajouter AX,12h ; AX=0037h
Exemple 3:
; Dans les champs de données : mem dw 128 ; Dans le segment de programme : add mem,100 ; mémoire = 228
ADC Addition entière avec report
La commande adc ajoute le premier et le deuxième opérandes, en ajoutant la valeur de l'indicateur de report CF au résultat. La valeur originale du premier opérande (destination) est perdue, remplacée par le résultat de l'addition. Le deuxième opérande est inchangé. Le premier opérande de l'instruction adc peut être un registre (sauf un segment) ou une cellule mémoire, le deuxième opérande peut être un registre (sauf un segment), une cellule mémoire ou une valeur immédiate, mais il n'est pas permis de spécifier les deux opérandes simultanément comme cellules mémoire. Les opérandes peuvent être des octets ou des mots et représenter des nombres signés ou non signés. La commande adc (avec la commande add) est couramment utilisée pour ajouter des nombres 32 bits. La commande affecte les flags OF, SF, ZF, AF, PF et CF.
Exemple 1
Mov AX,1125h adc AX,2C25h ;AX=3D4Bh, si CF était = 1 ;AX=3D4Ah, si CF était = 0
Exemple 2; Dans les champs de données : numlow dw 0FFFFh ;Partie basse du 2ème terme numhigh dw 000Sh ;Partie haute du 2ème terme;Numéro 0005FFFFh=393215 ;Dans le segment de programme : mov AX,000Sh ;Partie basse du 1er terme mov BX, 0002h ; La partie la plus haute du 1er terme ;Numéro 00020005h=131077 ajouter AX,numlow ;Ajout des parties inférieures. AX=4, CF=1 adc BX, numhigh ;Ajout de parties supérieures avec;transfer.BX:AX=0008:0004h. ;Numéro 00080004h=524292
L'utilisation d'opérandes 32 bits et de modes d'adressage supplémentaires de processeurs 32 bits est acceptable. L'instruction adc avec des opérandes de 32 bits peut être utilisée pour ajouter des entiers de 64 bits. Exemple 3; Dans les champs de données mem321 dd 0FFFFFFFFh ;Partie basse du 1er terme mem32h dd 98765432h ;Partie haute du 1er terme ; Dans le segment de programme mov EAX,1 ;La partie basse du 2ème terme mov EBX,0 ;La partie haute du 2ème terme ajoute EAX,mem321 ;Ajoute les moitiés basses;Sum=100000000b>32 bits;EAX=000000h, report adc EBX,mem32h ;Ajoutez les anciennes moitiés ; et transférez. EBX=90000001h ; Montant : 9876543300000000h
AJOUTER Addition entière
La commande add ajoute le premier et le deuxième opérande. La valeur originale du premier opérande (destination) est perdue, remplacée par le résultat de l'addition. Le deuxième opérande est inchangé. Le premier opérande de la commande add peut être spécifié comme un registre (sauf un segment) ou une cellule mémoire, et le deuxième opérande peut être un registre (sauf un segment), une cellule mémoire ou une valeur immédiate, mais il est pas autorisé à définir les deux opérandes simultanément comme cellules mémoire. Les opérandes peuvent être des octets ou des mots et représenter des nombres signés ou non signés. La commande add peut être utilisée pour ajouter à la fois des entiers réguliers et des nombres décimaux binaires (en utilisant le registre AX pour stocker le résultat). Lors de l'ajout de nombres décimaux codés binaires (BCD) décompressés, utilisez la commande aaa après la commande add ; si des nombres compressés sont ajoutés, alors commandez daa. La commande affecte les flags OF, SF, ZF, AF, PF et CF. Exemple 1
Déplacement BX,lFFEh déplacement CX,3 ajouter BX,CX ;BX=2001h, CX=0003h
Exemple 2 déplacement AX,25h ajouter AX,12h ;AX=0037h
Exemple 3; Dans les champs de données : mem dw 128 ;Dans le segment de programme : add mem,100 ;mem=228
Exemple 4 mov AX,0507h ;BCD décompressé 57 ajouter AL,05h ;BCD 5, AX=050Ch aaa ;AX=0602h, BCD 62
Exemple 5 mov AL,57h ;BCD emballé 57 ajouter AL,05h ;BCD 5, AL=5Ch daa ;AL=62h, BCD 62
L'utilisation d'opérandes 32 bits et de modes d'adressage supplémentaires de processeurs 32 bits est acceptable. Exemple
Déplacement EAX,98765432h ajouter EAX,11111111h ; EAX=A9876543h
ET ET logique
La commande and effectue une multiplication logique (au niveau du bit) du premier opérande par le second. La valeur originale du premier opérande (destination) est perdue, remplacée par le résultat de la multiplication. Le premier opérande de la commande et peut être un registre (sauf celui d'un segment) ou une cellule mémoire, le deuxième opérande peut être un registre (sauf celui d'un segment), une cellule mémoire ou une valeur immédiate, mais il n'est pas permis de spécifiez les deux opérandes simultanément comme cellules mémoire. Les opérandes peuvent être des octets ou des mots. La commande affecte les flags SF, ZF et PF. Règles de multiplication au niveau du bit :
Premier bit d'opérande 0101 Deuxième bit d'opérande 0011 Bit de résultat 0001 Exemple 1 déplacement AX,0FFEh et AX,5555h ;AX=0554h Exemple 2; Dans les champs de données : mem dw 0С003h ;Dans le segment de programme : mov AX,700Eh et AX,mem ;AX=4002h
L'utilisation d'opérandes 32 bits et de modes d'adressage supplémentaires de processeurs 32 bits est acceptable. Exemple
Mouvement EDX, 0FA8 8 0 0 4 lh et EDX,0FF00000Fh ; EDX = FA000001h
386P+ARPL
Ajustement du niveau de privilège du sélecteur demandé
La commande aprl compare le sélecteur à un modèle contenant le niveau de privilège maximum autorisé (généralement le sélecteur CS) et définit la valeur à tester sur le plus bas des deux niveaux de privilège. Si le changement de niveau n'est pas nécessaire, le drapeau ZF est réinitialisé ; si nécessaire, il est activé. Le premier opérande de l'instruction aprl peut être un registre de 16 bits ou un mot mémoire avec un sélecteur vérifiable ; le deuxième opérande est un registre de 16 bits avec un sélecteur de modèle. 386+ LIÉS
Vérification d'un index de tableau pour un tableau hors limites
La commande liée vérifie si l'index spécifié, traité comme un nombre signé, se situe dans les limites spécifiées par le deuxième opérande. Si l'index dépasse les limites du tableau en dessous ou au-dessus, une interruption est générée avec le vecteur 5. Le premier opérande doit être un registre contenant l'index à vérifier, le second - l'adresse d'un champ mémoire avec deux limites du tableau en cours de vérification. La commande liée autorise les opérandes 16 bits et 32 bits (mais le premier et le deuxième opérande doivent être du même type).
Assembleur- Langage d'assemblage pour les nuls
Langage d'assemblage pour les nuls.(#2) (C) Mikhaïl Spitsyne 1995 Drapeaux Le registre "F" du processeur est appelé flag. Ce que c'est? Un indicateur est une variable qui peut avoir deux états : activé (égal à un) et effacé (égal à zéro). Par conséquent, le registre « F » peut être considéré comme un ensemble de huit bits indicateurs. Nous ne pouvons en utiliser que quatre : le drapeau zéro, le drapeau de retenue, le drapeau de signe et le drapeau de dépassement de parité.Opérations arithmétiques. L'arithmétique est une science très, très utile ; on compte constamment quelque chose : additionner, soustraire, diviser, multiplier. Nous allons maintenant parler de la façon de procéder en assembleur. Nous allons commencer par le plus simple, ajouter un à quelque chose, par exemple pour enregistrer "A" : **************************** **** ** LD A,NUBER INC A RET ******************************* Comme vous pouvez le constater, il c'est très simple pour cela il y a une commande "INC" - incrément (augmenter de un), suivi d'un opérande, c'est à dire certains registres ou paires de registres : ******************************** INC A INC HL INC H INC DE INC E INC IY INC E INC (HL) INC (IX+N) INC (IY+N) ****************************** ** Si vous devez augmenter une cellule de mémoire d'une unité, procédez comme suit : ********************************** ****** *** LD HL,ADDRES LD IX,ADDRES INC (HL) INC (IX+0) RET RET ********************* **************** ***** La première option fonctionne plus rapidement et est plus pratique si vous travaillez avec une seule cellule mémoire, mais si vous travaillez dans un tableau, ce n'est pas le cas. économique et moche. Comparez : nous devons augmenter de un les premier, cinquième et dixième octets du tableau : ******************************* * LD HL,TABL+1 LD IX,TABL INC (HL) INC (IX+1) LD HL,TABL+5 INC (IX+5) INC (HL) INC (IX+10) LD HL,TABL+10 RET INC (HL) RET ******************************* Tout ce qui a été dit ci-dessus à propos d'une augmentation de un est vrai et pour décrémenter, c'est-à-dire pour diminuer d'un : ******************************** DEC A DEC HL DEC L DEC IX DEC H DEC DE DEC E DEC BC DEC D DEC IY DEC C DEC IX DEC B DEC (HL) DEC (IX+N) DEC (IX+N) ********************* *********** Supposons maintenant que nous devions augmenter le registre « A » non pas de un, mais, disons, de dix : **************** * *************** LD A, NUMÉRO AJOUTER A, 10 RET ************************* * ****** Vous pouvez ajouter un registre "A" avec un numéro et d'autres registres et avec une cellule mémoire adressée par des paires de registres "HL", "IX" et "IY". Vous pouvez également ajouter des paires de registres avec « HL », « IX » et « IY ». (PureBasic - système de fichiers) ******************************** ADD A,N ADD A,(HL) ADD A ,A ADD A,(IX+N) ADD A,B ADD A,(IY+N) ADD A,C ADD HL,HL ADD A,D ADD HL,BC ADD A,E ADD HL,DE ADD A,H ADD HL,SP ADD IX,IX ADD IX,BC ADD IX,DE ADD IX,SP ****************************** ** Comme vous pouvez le constater, l'ensemble des commandes est assez vaste. Lors de l'exécution de cette commande, une erreur peut survenir : ******************************** LD A,45 LD B,230 ADD A ,B RET ******************************** La somme de "A" et "B" a dépassé 255 et donc dans "A" " ce ne sera pas 275, mais 20 (le registre "A" n'est pas en caoutchouc); Pour nous informer qu'un débordement s'est produit, le processeur définit l'indicateur de report sur un. Il ne reste plus qu'à le vérifier. Tout comme "INC" a "DEC", "ADD" a aussi un "couple", c'est "SUB", et il a ses propres caractéristiques. La commande "SUB" ne fonctionne qu'avec le registre "A", donc lors de l'écriture des mnémoniques de cette commande, "A" est omis : ********************* *********** SUB N SUB C SUB A SUB H SUB B SUB D SUB E SUB (HL) SUB (IX+N) SUB (IY+N) ******** * ********************** La commande affecte le drapeau de report de la même manière que « ADD ». En plus de la paire de commandes "ADD" et "SUB", il existe une autre paire. Les commandes "ADC" et "SBC" fonctionnent en tenant compte du carry flag, c'est-à-dire Lors de l'ajout ou de la soustraction, la valeur de l'indicateur de report est ajoutée (soustraite) au résultat. Il existe deux commandes spéciales pour définir l'indicateur de report : "SCF" et "CCF". "SCF" - définit l'indicateur de report sur un. "CCF" - met l'indicateur de report à zéro. ******************************** ADC A,N SBC A,N ADC A,A SBC A,A ADC A ,H SBC A,H ADC A,L SBC A,L ADC A,D SBC A,D ADC A,E SBC A,E ADC A,B SBC A,B ADC A,C SBC A,C ADC A,( HL) SBC A,(HL) ADC A,(IX+N) SBC A,(IX+N) ADC A,(IY+N) SBC A,)IY+N) ADC HL,HL SBC HL,HL ADC HL ,BC SBC HL,BC ADC HL,DE SBC HL,DE ADC HL,SP SBC HL,SP **************************** **** Et maintenant des exemples de fonctionnement des commandes « ADC » et « SBC » : ***************************** ************ * LD A,10 LD A,10 LD B,5 LD B,5 CCF CCF SBC A,B ADC A,B RET RET A=5 B=5 A=15 B=5 ******** ********************** Au lieu des deux commandes « CCF » et « SBC A,B », vous vous pouvez simplement mettre « SUB B », le résultat sera le même. ******************************** LD A,10 LD A,10 LD B,5 LD B,5 SCF SCF SBC A,B ADC A,B RET RET A=4 B=5 A=16 B=5 **************************** **** Comme le montrent les résultats, le drapeau de report affecte de manière significative le résultat de l'opération. Lors de la soustraction, il est soustrait du résultat, et lors de l'ajout, il est ajouté au résultat. Presque tout a été vu sur les opérations d'addition et de soustraction ; nous allons maintenant parler de division et de multiplication. Malheureusement SPECCY ne dispose pas de commandes de division et de multiplication, mais ces commandes peuvent être composées de plusieurs autres. Par exemple, nous devons multiplier le contenu de deux registres - « A » et « C » : ***************************** ********** *** LD A,10 LD C,5 LD B,A XOR A LOOP ADD A,C DJNZ LOOP RET *************** ********** ******* Dans l'exemple, il y a deux nouvelles commandes - « XOR A » et « DJNZ LOOP ». "XOR A" efface le registre "A" et la commande "DJNZ LOOP" répète toutes les commandes, de la commande marquée d'une étiquette (par exemple, "LOOP") à la commande "DJNZ" (suivie de la même étiquette). ka, comme au début du cycle) ; le nombre de répétitions est précisé dans le registre "B". En utilisant le fait que multiplier M par N revient à ajouter le nombre M à lui-même N fois, vous pouvez comprendre l'exemple donné ci-dessus. Cette propriété peut également être utilisée pour la division. Essayez-le vous-même. La prochaine fois, nous parlerons des commandes permettant de comparer et de travailler avec des bits.________________________________Autres articles dans le numéro :
