Ensemble d'instructions (Opcodes)
Le 6502 possède un ensemble de 56 instructions officielles. Malgré ce nombre réduit, le microprocesseur est capable de réaliser des programmes complets et performants grâce a l'utilisation combinée de ses modes d'adressage variés.
Chaque instruction est codée sur un octet (opcode). Selon le mode d'adressage, l'instruction complète occupe 1, 2 ou 3 octets en mémoire. Le nombre total d'opcodes valides est de 151 (sur 256 combinaisons possibles).
L'ensemble d'instructions se divise en catégories :
- Transfert de données (chargement, stockage, transfert entre registres)
- Arithmétique (addition, soustraction, incrément, décrément)
- Opérations logiques (ET, OU, OU exclusif)
- Décalages et rotations
- Comparaison et test de bits
- Branchements conditionnels
- Sauts et appels de sous-programmes
- Opérations de pile
- Contrôle des drapeaux
- Instruction NOP
Conventions de notation utilisées dans cette section :
| Notation | Description |
|---|---|
| A | Accumulateur |
| X | Registre d'index X |
| Y | Registre d'index Y |
| SP | Pointeur de pile |
| PC | Compteur programme |
| P | Registre d'état du processeur |
| M | Contenu de l'emplacement mémoire adresse |
| nn | Valeur 8 bits (opérande immédiat ou adresse page zéro) |
| nnnn | Valeur 16 bits (adresse absolue) |
| [CCR] | Drapeaux affectes (N, V, -, B, D, I, Z, C) |
| -> ou → | Affectation (résultat vers destination) |
| $ | Préfixe hexadécimal |
| # | Préfixe immédiat (la valeur elle-même, pas une adresse) |
Pour chaque instruction, les informations suivantes sont données :
- Mnémonique et description
- Modes d'adressage disponibles avec l'opcode correspondant
- Taille de l'instruction en octets
- Nombre de cycles d'exécution
- Drapeaux affectes
Instructions de transfert de données
Ces instructions copient des données entre les registres et la mémoire, ou entre les registres eux-mêmes.
LDA - Load Accumulator (Charger l'accumulateur)
Charge une valeur dans l'accumulateur A.
Opération : A ← M
Drapeaux affectes : N, Z
- N = 1 si le bit 7 du résultat est 1
- Z = 1 si le résultat est 0
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | LDA #$nn | $A9 | 2 | 2 |
| Page zéro | LDA $nn | $A5 | 2 | 3 |
| Page zero,X | LDA $nn,X | $B5 | 2 | 4 |
| Absolu | LDA $nnnn | $AD | 3 | 4 |
| Absolu,X | LDA $nnnn,X | $BD | 3 | 4(+1) |
| Absolu,Y | LDA $nnnn,Y | $B9 | 3 | 4(+1) |
| (Indirect,X) | LDA ($nn,X) | $A1 | 2 | 6 |
| (Indirect),Y | LDA ($nn),Y | $B1 | 2 | 5(+1) |
(+1) = +1 cycle si franchissement de page (page boundary crossing)
Exemples :
LDX - Load X Register (Charger le registre X)
Charge une valeur dans le registre d'index X.
Opération : X ← M
Drapeaux affectes : N, Z
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | LDX #$nn | $A2 | 2 | 2 |
| Page zéro | LDX $nn | $A6 | 2 | 3 |
| Page zéro,Y | LDX $nn,Y | $B6 | 2 | 4 |
| Absolu | LDX $nnnn | $AE | 3 | 4 |
| Absolu,Y | LDX $nnnn,Y | $BE | 3 | 4(+1) |
Exemples :
Remarque :
- LDX utilise Zero Page,Y (et non Zero Page,X), car indexer le chargement de X par X serait un conflit logique
LDY - Load Y Register (Charger le registre Y)
Charge une valeur dans le registre d'index Y.
Opération : Y ← M
Drapeaux affectes : N, Z
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | LDY #$nn | $A0 | 2 | 2 |
| Page zero | LDY $nn | $A4 | 2 | 3 |
| Page zero,X | LDY $nn,X | $B4 | 2 | 4 |
| Absolu | LDY $nnnn | $AC | 3 | 4 |
| Absolu,X | LDY $nnnn,X | $BC | 3 | 4(+1) |
Exemples :
STA - Store Accumulator (Entreposer l'accumulateur)
Entrepose le contenu de l'accumulateur A en mémoire.
Opération : M ← A
Drapeaux affectes : aucun
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zero | STA $nn | $85 | 2 | 3 |
| Page zero,X | STA $nn,X | $95 | 2 | 4 |
| Absolu | STA $nnnn | $8D | 3 | 4 |
| Absolu,X | STA $nnnn,X | $9D | 3 | 5 |
| Absolu,Y | STA $nnnn,Y | $99 | 3 | 5 |
| (Indirect,X) | STA ($nn,X) | $81 | 2 | 6 |
| (Indirect),Y | STA ($nn),Y | $91 | 2 | 6 |
Exemples :
Remarques :
- STA n'a pas de mode immédiat (on ne peut pas entreposer dans une constante)
- Les modes indexes prennent toujours le même nombre de cycles, sans pénalité de franchissement de page (contrairement a LDA)
STX - Store X Register (Entreposer le registre X)
Entrepose le contenu du registre X en mémoire.
Opération : M ← X
Drapeaux affectes : aucun
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zéro | STX $nn | $86 | 2 | 3 |
| Page zero,Y | STX $nn,Y | $96 | 2 | 4 |
| Absolu | STX $nnnn | $8E | 3 | 4 |
Exemples :
- STX $80 ; stocker X a l'adresse $0080
- STX $2000 ; stocker X a l'adresse $2000
STY - Store Y Register (Entreposer le registre Y)
Entrepose le contenu du registre Y en mémoire.
Opération : M ← Y
Drapeaux affectes : aucun
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zéro | STY $nn | $84 | 2 | 3 |
| Page zero,X | STY $nn,X | $94 | 2 | 4 |
| Absolu | STY $nnnn | $8C | 3 | 4 |
Exemples :
- STY $80 ; entreposer Y a l'adresse $0080
- STY $2000 ; entreposer Y a l'adresse $2000
Transferts entre registres
Ces instructions copient une valeur d'un registre vers un autre. Elles n'ont pas d'opérande (mode implicite), occupent 1 octet et s'exécutent en 2 cycles.
| Instruction | Opération |
|---|---|
| TAX ($AA) | A → X Drapeaux : N, Z |
| TAY ($A8) | A → Y Drapeaux : N, Z |
| TXA ($8A) | X → A Drapeaux : N, Z |
| TYA ($98) | Y → A Drapeaux : N, Z |
| TSX ($BA) | SP → X Drapeaux : N, Z |
| TXS ($9A) | X → SP Drapeaux : aucun |
Exemples :
- ; Copier A dans X pour utiliser X comme index
- TAX ; X := A
-
- ; Sauvegarder le pointeur de pile dans X
- TSX ; X := SP
-
- ; Initialiser le pointeur de pile
- LDX #$FF
- TXS ; SP := $FF (pile pleine)
-
- ; Echanger A et X (pas d'instruction directe)
- TAX ; sauver A dans X
- ; ... (utiliser A pour autre chose)
- TXA ; restaurer A depuis X
Remarques :
- TXS est la SEULE instruction de transfert qui ne modifie pas les drapeaux. Ceci permet d'initialiser la pile sans perturber l'état des drapeaux.
- TSX transfère le pointeur de pile (8 bits) dans X. Le pointeur de pile va de $00 a $FF, représentant les adresses $0100 a $01FF.
- Il n'existe pas d'instruction directe pour échanger deux registres (pas de SWAP, EXG ou XCHG).
Instructions arithmétiques
Le 6502 dispose d'instructions d'addition et de soustraction avec retenue, ainsi que d'instructions d'incrément et de décrément.
ADC - Add with Carry (Addition avec retenue)
Ajoute la valeur de l'opérande et du drapeau de retenue (C) a l'accumulateur.
Opération : A ← A + M + C
Drapeaux affectes : N, V, Z, C
- N = 1 si le bit 7 du résultat est 1
- V = 1 si débordement signe (le résultat sort de -128..+127)
- Z = 1 si le résultat est 0
- C = 1 si le résultat dépasse 255 (retenue sortante)
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | ADC #$nn | $69 | 2 | 2 |
| Page zéro | ADC $nn | $65 | 2 | 3 |
| Page zero,X | ADC $nn,X | $75 | 2 | 4 |
| Absolu | ADC $nnnn | $6D | 3 | 4 |
| Absolu,X | ADC $nnnn,X | $7D | 3 | 4(+1) |
| Absolu,Y | ADC $nnnn,Y | $79 | 3 | 4(+1) |
| (Indirect,X) | ADC ($nn,X) | $61 | 2 | 6 |
| (Indirect),Y | ADC ($nn),Y | $71 | 2 | 5(+1) |
Exemples :
- ; Addition simple 8 bits : A = $30 + $10
- CLC ; TOUJOURS effacer C avant une addition
- LDA #$30
- ADC #$10 ; A = $40, C = 0
-
- ; Addition 16 bits : resultat = $80/$81 + $82/$83
- CLC ; effacer la retenue
- LDA $80 ; poids faible de la 1ere valeur
- ADC $82 ; + poids faible de la 2e valeur
- STA $84 ; stocker le poids faible du resultat
- LDA $81 ; poids fort de la 1ere valeur
- ADC $83 ; + poids fort + retenue de l'addition precedente
- STA $85 ; stocker le poids fort du resultat
-
- ; Addition 8 bits avec retenue entrante
- ; (par ex. pour une chaine d'additions multi-precision)
- ADC $90 ; A = A + [$90] + C
Mode décimal (BCD) :
- Si le drapeau D est positionne (SED), ADC effectue une addition en décimal code binaire (BCD). Chaque octet représente deux chiffres décimaux (0-9 dans chaque quartet).
Remarques :
- Il faut TOUJOURS effacer C (CLC) avant la première addition d'une séquence, sinon un '1' résiduel dans C faussera le résultat
- Le 6502 n'a PAS d'instruction ADD sans retenue. ADC est la seule instruction d'addition.
- Le drapeau V (overflow) détecte les débordements en arithmétique signée (complément à deux)
- Le comportement du drapeau N après une ADC en mode BCD est indéterminé sur le 6502 NMOS. Le 65C02 (CMOS) corrige ce comportement.
SBC - Subtract with Carry (Soustraction avec retenue)
Soustrait la valeur de l'opérande et le complément du drapeau de retenue (borrow) de l'accumulateur.
Opération : A ← A - M - NOT(C)
(équivalent a : A ← A - M - (1 - C))
Drapeaux affectes : N, V, Z, C
- N = 1 si le bit 7 du résultat est 1
- V = 1 si débordement signe
- Z = 1 si le résultat est 0
- C = 0 si emprunt (le résultat est négatif en non signe)
- C = 1 si pas d'emprunt
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | SBC #$nn | $E9 | 2 | 2 |
| Page zero | SBC $nn | $E5 | 2 | 3 |
| Page zero,X | SBC $nn,X | $F5 | 2 | 4 |
| Absolu | SBC $nnnn | $ED | 3 | 4 |
| Absolu,X | SBC $nnnn,X | $FD | 3 | 4(+1) |
| Absolu,Y | SBC $nnnn,Y | $F9 | 3 | 4(+1) |
| (Indirect,X) | SBC ($nn,X) | $E1 | 2 | 6 |
| (Indirect),Y | SBC ($nn),Y | $F1 | 2 | 5(+1) |
Exemples :
- ; Soustraction simple 8 bits : A = $50 - $10
- SEC ; TOUJOURS positionner C avant une soustraction
- LDA #$50
- SBC #$10 ; A = $40, C = 1 (pas d'emprunt)
-
- ; Soustraction 16 bits : resultat = $80/$81 - $82/$83
- SEC ; positionner la retenue (pas d'emprunt)
- LDA $80 ; poids faible de la 1ere valeur
- SBC $82 ; - poids faible de la 2e valeur
- STA $84 ; stocker le poids faible du resultat
- LDA $81 ; poids fort de la 1ere valeur
- SBC $83 ; - poids fort - emprunt eventuel
- STA $85 ; stocker le poids fort du resultat
-
- ; Negation (complement a deux) : A = 0 - A
- EOR #$FF ; complement a un
- CLC
- ADC #$01 ; + 1 = complement a deux
Remarques :
- Il faut TOUJOURS positionner C (SEC) avant la première soustraction d'une séquence (C=1 signifie "pas d'emprunt")
- Le sens du drapeau C est INVERSE par rapport a l'emprunt :
- C=1 après SBC signifie PAS d'emprunt (résultat >= 0)
- C=0 après SBC signifie emprunt (résultat < 0 en non signe)
- Le 6502 n'a PAS d'instruction SUB sans retenue
- En mode BCD (drapeau D), SBC effectue une soustraction en décimal code binaire
INC - Increment Memory (Incrementer la memoire)
Incrémente de 1 la valeur a l'emplacement mémoire spécifié.
Opération : M ← M + 1
Drapeaux affectes : N, Z
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zéro | INC $nn | $E6 | 2 | 5 |
| Page zero,X | INC $nn,X | $F6 | 2 | 6 |
| Absolu | INC $nnnn | $EE | 3 | 6 |
| Absolu,X | INC $nnnn,X | $FE | 3 | 7 |
Exemples :
Remarque :
- INC ne peut pas opérer directement sur l'accumulateur A. Pour incrémenter A, utiliser CLC + ADC #$01 (ou INA sur le 65C02 qui ajoute l'instruction INC A).
- INC ne modifie pas le drapeau C (retenue). Si la valeur passe de $FF a $00, seul Z est positionne.
INX - Increment X Register (Incrémenter X)
Incrémente de 1 le registre X.
Opération : X ← X + 1
Drapeaux affectes : N, Z
| Opcode | Taille | Cycles |
|---|---|---|
| $E8 | 1 octet | 2 |
Exemple :
- INX ; X := X + 1
INY - Increment Y Register (Incrementer Y)
Incrémente de 1 le registre Y.
Opération : Y ← Y + 1
Drapeaux affectes : N, Z
| Opcode | Taille | Cycles |
|---|---|---|
| $C8 | 1 octet | 2 |
Exemple :
- INY ; Y := Y + 1
DEC - Decrement Memory (Décrémenter la mémoire)
Décrementé de 1 la valeur à l'emplacement mémoire spécifié.
Opération : M ← M - 1
Drapeaux affectes : N, Z
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zero | DEC $nn | $C6 | 2 | 5 |
| Page zero,X | DEC $nn,X | $D6 | 2 | 6 |
| Absolu | DEC $nnnn | $CE | 3 | 6 |
| Absolu,X | DEC $nnnn,X | $DE | 3 | 7 |
Exemples :
Remarque :
- Comme INC, DEC ne peut pas opérer sur A directement. Utiliser SEC + SBC #$01 (ou DEC A / DEA sur le 65C02).
DEX - Decrement X Register (Decrementer X)
Décrémente de 1 le registre X.
Operation : X ← X - 1
Drapeaux affectes : N, Z
| Opcode | Taille | Cycles |
|---|---|---|
| $CA | 1 octet | 2 |
Exemple :
DEY - Decrement Y Register (Décrémenter Y)
Décrementé de 1 le registre Y.
Opération : Y ← Y - 1
Drapeaux affectes : N, Z
| Opcode | Taille | Cycles |
|---|---|---|
| $88 | 1 octet | 2 |
Exemple :
Instructions logiques
Le 6502 dispose de trois opérations logiques bit a bit qui opèrent sur l'accumulateur A.
AND - Logical AND (ET logique)
Effectue un ET logique bit a bit entre l'accumulateur et l'opérande.
Opération : A ← A AND M
Drapeaux affectes : N, Z
Table de vérité :
| A | M | Résultat |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | AND #$nn | $29 | 2 | 2 |
| Page zero | AND $nn | $25 | 2 | 3 |
| Page zero,X | AND $nn,X | $35 | 2 | 4 |
| Absolu | AND $nnnn | $2D | 3 | 4 |
| Absolu,X | AND $nnnn,X | $3D | 3 | 4(+1) |
| Absolu,Y | AND $nnnn,Y | $39 | 3 | 4(+1) |
| (Indirect,X) | AND ($nn,X) | $21 | 2 | 6 |
| (Indirect),Y | AND ($nn),Y | $31 | 2 | 5(+1) |
Exemples :
Utilisation typique :
- Masquage de bits (isoler certains bits)
- Tester si un bit est positionne (AND + BEQ/BNE)
- Effacer des bits spécifiques
ORA - Logical Inclusive OR (OU inclusif logique)
Effectue un OU logique bit a bit entre l'accumulateur et l'opérande.
Opération : A ← A OR M
Drapeaux affectes : N, Z
Table de vérité :
| A | M | Résultat |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | ORA #$nn | $09 | 2 | 2 |
| Page zero | ORA $nn | $05 | 2 | 3 |
| Page zero,X | ORA $nn,X | $15 | 2 | 4 |
| Absolu | ORA $nnnn | $0D | 3 | 4 |
| Absolu,X | ORA $nnnn,X | $1D | 3 | 4(+1) |
| Absolu,Y | ORA $nnnn,Y | $19 | 3 | 4(+1) |
| (Indirect,X) | ORA ($nn,X) | $01 | 2 | 6 |
| (Indirect),Y | ORA ($nn),Y | $11 | 2 | 5(+1) |
Exemples :
- ORA #$80 ; forcer le bit 7 a 1
- ORA #$01 ; forcer le bit 0 a 1
- ORA #%00001111 ; forcer les 4 bits de poids faible a 1
Utilisation typique :
- Positionner (mettre a 1) des bits spécifiques
- Combiner des valeurs masquées
- Construire un octet bit par bit
EOR - Exclusive OR (OU exclusif logique)
Effectue un OU exclusif (XOR) bit a bit entre l'accumulateur et l'opérande.
Opération : A ← A XOR M
Drapeaux affectes : N, Z
Table de vérité :
| A | M | Résultat |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | EOR #$nn | $49 | 2 | 2 |
| Page zero | EOR $nn | $45 | 2 | 3 |
| Page zero,X | EOR $nn,X | $55 | 2 | 4 |
| Absolu | EOR $nnnn | $4D | 3 | 4 |
| Absolu,X | EOR $nnnn,X | $5D | 3 | 4(+1) |
| Absolu,Y | EOR $nnnn,Y | $59 | 3 | 4(+1) |
| (Indirect,X) | EOR ($nn,X) | $41 | 2 | 6 |
| (Indirect),Y | EOR ($nn),Y | $51 | 2 | 5(+1) |
Exemples :
- EOR #$FF ; inverser tous les bits (complement a 1)
- EOR #$80 ; inverser le bit 7 (changer le signe)
- EOR #$01 ; inverser le bit 0 (basculer un flag)
Utilisation typique :
- Inverser (basculer) des bits spécifiques
- Complément a 1 (EOR #$FF)
- Clignotement d'un caractère a l'écran (EOR avec un masque)
- Cryptage simple (XOR avec une clef)
- Tester si deux valeurs sont égales (EOR + BEQ)
Instructions de décalage et rotation
Ces instructions décalent ou font tourner les bits d'un octet vers la gauche ou la droite. Elles peuvent opérer sur l'accumulateur A ou directement sur un emplacement mémoire.
ASL - Arithmetic Shift Left (Décalage arithmétique a gauche)
Décale tous les bits d'une position vers la gauche. Le bit 7 sort dans C et un 0 entre dans le bit 0.
Opération : C ← [76543210] ← 0
Drapeaux affectes : N, Z, C
- C = ancien bit 7
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Accumulateur | ASL A | $0A | 1 | 2 |
| Page zero | ASL $nn | $06 | 2 | 5 |
| Page zero,X | ASL $nn,X | $16 | 2 | 6 |
| Absolu | ASL $nnnn | $0E | 3 | 6 |
| Absolu,X | ASL $nnnn,X | $1E | 3 | 7 |
Exemples :
LSR - Logical Shift Right (Décalage logique a droite)
Décale tous les bits d'une position vers la droite. Un 0 entre dans le bit 7 et le bit 0 sort dans C.
Opération : 0 → [76543210] → C
Drapeaux affectes : N (toujours 0), Z, C
- C = ancien bit 0
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Accumulateur | LSR A | $4A | 1 | 2 |
| Page zero | LSR $nn | $46 | 2 | 5 |
| Page zero,X | LSR $nn,X | $56 | 2 | 6 |
| Absolu | LSR $nnnn | $4E | 3 | 6 |
| Absolu,X | LSR $nnnn,X | $5E | 3 | 7 |
Exemples :
- LSR A ; A = A / 2 (division entiere non signee)
- ; Diviser A par 4 :
- LSR A ; A / 2
- LSR A ; A / 4
-
- ; Tester le bit 0 de A :
- LSR A ; bit 0 -> C
- BCS BitEstUn ; brancher si le bit 0 etait 1
ROL - Rotate Left (Rotation a gauche via C)
Fait tourner tous les bits d'une position vers la gauche a travers le drapeau C. Le bit 7 sort dans C et l'ancien C entre dans le bit 0.
Opération : C ← [76543210] ← C
Drapeaux affectes : N, Z, C
- C = ancien bit 7
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Accumulateur | ROL A | $2A | 1 | 2 |
| Page zero | ROL $nn | $26 | 2 | 5 |
| Page zero,X | ROL $nn,X | $36 | 2 | 6 |
| Absolu | ROL $nnnn | $2E | 3 | 6 |
| Absolu,X | ROL $nnnn,X | $3E | 3 | 7 |
Exemples :
- ; Rotation 16 bits a gauche de la valeur $80/$81
- ASL $80 ; decaler le poids faible, bit 7 -> C
- ROL $81 ; rotation du poids fort, C -> bit 0
-
- ; Lecture serie bit par bit dans C
- ROL A ; injecter C dans le bit 0, bit 7 -> C
ROR - Rotate Right (Rotation a droite via C)
Fait tourner tous les bits d'une position vers la droite a travers le drapeau C. Le bit 0 sort dans C et l'ancien C entre dans le bit 7.
- Opération : C → [76543210] → C
Drapeaux affectes : N, Z, C
- C = ancien bit 0
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Accumulateur | ROR A | $6A | 1 | 2 |
| Page zero | ROR $nn | $66 | 2 | 5 |
| Page zero,X | ROR $nn,X | $76 | 2 | 6 |
| Absolu | ROR $nnnn | $6E | 3 | 6 |
| Absolu,X | ROR $nnnn,X | $7E | 3 | 7 |
Exemples :
- ; Rotation 16 bits a droite de la valeur $80/$81
- LSR $81 ; decaler le poids fort, bit 0 -> C
- ROR $80 ; rotation du poids faible, C -> bit 7
-
- ; Division signee par 2 (conserver le signe)
- CMP #$80 ; copier le bit 7 (signe) dans C
- ROR A ; diviser par 2 en conservant le signe
Note historique : L'instruction ROR n'existait pas dans les premières révisions du 6502 (avant juin 1976). Elle a été ajoutée plus tard. Les premières documentations de MOS Technology ne la mentionnaient pas, et elle fonctionnait de manière erratique sur les premiers exemplaires du processeur.
Instructions de comparaison
Ces instructions comparent un registre avec une valeur en mémoire en effectuant une soustraction interne sans modifier le registre. Seuls les drapeaux sont affectes.
CMP - Compare Accumulator (Comparer avec A)
Compare l'accumulateur avec la valeur en mémoire.
Opération : A - M (résultat non conserve)
Drapeaux affectes : N, Z, C
- N = 1 si le bit 7 du résultat (A-M) est 1
- Z = 1 si A = M
- C = 1 si A >= M (non signe)
- C = 0 si A < M (non signe)
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | CMP #$nn | $C9 | 2 | 2 |
| Page zero | CMP $nn | $C5 | 2 | 3 |
| Page zero,X | CMP $nn,X | $D5 | 2 | 4 |
| Absolu | CMP $nnnn | $CD | 3 | 4 |
| Absolu,X | CMP $nnnn,X | $DD | 3 | 4(+1) |
| Absolu,Y | CMP $nnnn,Y | $D9 | 3 | 4(+1) |
| (Indirect,X) | CMP ($nn,X) | $C1 | 2 | 6 |
| (Indirect),Y | CMP ($nn),Y | $D1 | 2 | 5(+1) |
Exemples et idiomes :
- ; Tester si A = $42
- CMP #$42
- BEQ Egal ; brancher si A = $42
-
- ; Tester si A < $20 (non signe)
- CMP #$20
- BCC Inferieur ; brancher si A < $20
-
- ; Tester si A >= $80 (non signe)
- CMP #$80
- BCS SupOuEgal ; brancher si A >= $80
-
- ; Tester si A est dans la plage 'A'-'Z'
- CMP #'A'
- BCC PasLettre ; A < 'A'
- CMP #'Z'+1
- BCS PasLettre ; A > 'Z'
- ; Ici, A est une lettre majuscule
CPX - Compare X Register (Comparer avec X)
Compare le registre X avec la valeur en mémoire.
Opération : X - M (résultat non conserve)
Drapeaux affectes : N, Z, C (mêmes règles que CMP)
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | CPX #$nn | $E0 | 2 | 2 |
| Page zero | CPX $nn | $E4 | 2 | 3 |
| Absolu | CPX $nnnn | $EC | 3 | 4 |
Exemples :
- CPX #$10
- BEQ XEstSeize ; brancher si X = 16
- CPX #$00
- BEQ XEstZero ; brancher si X = 0
CPY - Compare Y Register (Comparer avec Y)
Compare le registre Y avec la valeur en mémoire.
Opération : Y - M (résultat non conserve)
Drapeaux affectes : N, Z, C (mêmes règles que CMP)
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Immediat | CPY #$nn | $C0 | 2 | 2 |
| Page zero | CPY $nn | $C4 | 2 | 3 |
| Absolu | CPY $nnnn | $CC | 3 | 4 |
Exemples :
- CPY #$18 ; comparer Y avec 24
- BCS SupOuEgal ; brancher si Y >= 24
BIT - Test Bits (Test de bits)
Teste des bits en mémoire contre l'accumulateur sans modifier ni A ni M. C'est une instruction unique positionnant trois drapeaux de manières différentes.
Opération :
- Z = 1 si (A AND M) = 0 (résultat du masquage est zéro)
- N = bit 7 de M (copie directe, sans tenir compte de A)
- V = bit 6 de M (copie directe, sans tenir compte de A)
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Page zero | BIT $nn | $24 | 2 | 3 |
| Absolu | BIT $nnnn | $2C | 3 | 4 |
Exemples :
- ; Tester si le bit 7 d'un registre materiel est positionne
- BIT $D011 ; lire le registre VIC-II
- BMI BitSept ; brancher si bit 7 = 1 (N = bit 7 de M)
-
- ; Tester si le bit 6 est positionne
- BIT $D011
- BVS BitSix ; brancher si bit 6 = 1 (V = bit 6 de M)
-
- ; Tester si certains bits sont a 1 dans un registre
- LDA #%00001100 ; masque : bits 2 et 3
- BIT Registre ; tester
- BNE AuMoinsUnBit ; au moins un des bits 2 ou 3 est a 1
-
- ; Attendre qu'un peripherique soit pret (polling)
- Attendre:
- BIT StatutPerif ; tester le registre de statut
- BPL Attendre ; boucler tant que bit 7 = 0
Remarques :
- BIT est très utile pour tester des registres matériels (memory-mapped I/O) sans modifier l'accumulateur
- Le comportement de N et V est unique : ils reçoivent directement les bits 7 et 6 de l'opérande mémoire, indépendamment de la valeur de A
- Le 65C02 ajoute le mode immédiat (BIT #$nn) ou seul Z est affecte (N et V ne sont pas modifiés)
Instructions de branchement
Les instructions de branchement effectuent un saut relatif conditionnel. Elles testent un drapeau du registre d'état et, si la condition est vraie, ajoutent un déplacement signe de 8 bits au compteur programme.
Toutes les instructions de branchement :
- Font 2 octets (opcode + déplacement)
- Prennent 2 cycles si le branchement n'est pas pris
- Prennent 3 cycles si le branchement est pris (même page)
- Prennent 4 cycles si le branchement est pris avec franchissement de page
BCC - Branch if Carry Clear (Brancher si C = 0)
Branche si le drapeau de retenue est efface.
Opcode : $90
Utilisation : après CMP/CPX/CPY pour tester "inferieur a" (comparaison non signée)
Exemple :
- CMP #$80
- BCC InferieurA128 ; brancher si A < $80
BCS - Branch if Carry Set (Brancher si C = 1)
Branche si le drapeau de retenue est positionne.
Opcode : $B0
Utilisation : après CMP/CPX/CPY pour tester "supérieur ou égal" (comparaison non signée)
Exemple :
- CMP #$80
- BCS SupOuEgalA128 ; brancher si A >= $80
BEQ - Branch if Equal (Brancher si Z = 1)
Branche si le drapeau zéro est positionne (résultat égal à zéro).
Opcode : $F0
Utilisation : après CMP pour tester "égal a", après LDA/LDX/LDY pour tester si la valeur chargée est zéro
Exemples :
BNE - Branch if Not Equal (Brancher si Z = 0)
Branche si le drapeau zéro est efface (résultat non nul).
Opcode : $D0
Utilisation : après CMP pour tester "différent de", comme condition de boucle (compteur != 0)
Exemples :
BMI - Branch if Minus (Brancher si N = 1)
Branche si le drapeau négatif est positionne (bit 7 du résultat est 1).
Opcode : $30
Utilisation : tester le signe d'une valeur, tester le bit 7
Exemples :
- LDA Temperature
- BMI Negatif ; brancher si la temperature est negative
-
- BIT $D011
- BMI Pret ; brancher si bit 7 du registre = 1
BPL - Branch if Plus (Brancher si N = 0)
Branche si le drapeau négatif est efface (bit 7 du résultat est 0).
Opcode : $10
Utilisation : tester le signe d'une valeur, polling de périphériques
Exemples :
- ; Attendre que le bit 7 d'un registre passe a 1
- Attendre:
- BIT Registre
- BPL Attendre ; boucler tant que bit 7 = 0
-
- LDA Valeur
- BPL Positif ; brancher si >= 0 (en signe)
BVC - Branch if Overflow Clear (Brancher si V = 0)
Branche si le drapeau de débordement est efface.
Opcode : $50
Utilisation : rarement utilise, principalement pour l'arithmétique signée
Exemple :
- ADC Valeur
- BVC PasDebordement ; brancher si pas de débordement signe
BVS - Branch if Overflow Set (Brancher si V = 1)
Branche si le drapeau de débordement est positionne.
Opcode : $70
Utilisation : détection de débordement en arithmétique signée, lecture du pin SO (Set Overflow) de certains périphériques
Exemple :
- ADC Valeur
- BVS Debordement ; brancher si debordement signe
Remarques générales sur les branchements :
- Le déplacement est un entier signe de 8 bits : -128 a +127 par rapport a l'instruction suivant le branchement
- Portée effective : -126 a +129 octets par rapport a l'instruction de branchement elle-même
- Si la cible est hors de portée, utiliser un saut intermédiaire (trampoline) via JMP
- Le 65C02 ajoute BRA (branch always, branchement inconditionnel relatif)
- Le 6502 n'a PAS de branchements "branch if greater", "branch if less" en arithmétique signée en une seule instruction. Il faut combiner CMP + BCC/BCS/BEQ/BMI/BPL.
Instructions de saut et d'appel
Ces instructions modifient le compteur programme (PC) pour effectuer des sauts inconditionnels ou des appels de sous-programmes.
JMP - Jump (Saut inconditionnel)
Charge une nouvelle adresse dans le compteur programme.
Opération : PC ← adresse
Drapeaux affectes : aucun
Modes d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Absolu | JMP $nnnn | $4C | 3 | 3 |
| Indirect | JMP ($nnnn) | $6C | 3 | 5 |
Exemples :
- JMP $C000 ; sauter a l'adresse $C000
- JMP Suite ; sauter a l'etiquette Suite
- JMP ($FFFC) ; saut indirect via le vecteur RESET
- JMP (VecteurJmp) ; saut indirect via un pointeur en memoire
JSR - Jump to Subroutine (Appel de sous-programme)
Empile l'adresse de retour (PC - 1) sur la pile, puis saute a l'adresse spécifiée.
Operation : PUSH (PC - 1), PC ← adresse
(PC - 1 car le 6502 empile l'adresse du DERNIER octet de l'instruction JSR, pas l'adresse de l'instruction suivante. RTS ajoutera 1 pour obtenir la bonne adresse de retour.)
Drapeaux affectes : aucun
Mode d'adressage :
| Mode | Syntaxe | Opcode | Octets | Cycles |
|---|---|---|---|---|
| Absolu | JSR $nnnn | $20 | 3 | 6 |
Exemples :
- JSR SousRoutine ; appeler SousRoutine
- JSR $FFD2 ; appeler CHROUT du Kernal C64
Détail de l'empilage :
- SP pointe sur l'emplacement libre en haut de pile
- L'octet de poids fort de (PC-1) est empile : [$0100+SP] = PCH
SP := SP - 1 - L'octet de poids faible de (PC-1) est empile : [$0100+SP] = PCL
SP := SP - 1 - PC := adresse cible
RTS - Return from Subroutine (Retour de sous-programme)
Dépile l'adresse de retour de la pile et y ajoute 1 pour continuer l'exécution après l'instruction JSR correspondante.
Opération : PULL PC, PC ← PC + 1
Drapeaux affectes : aucun
| Opcode | Taille | Cycles |
|---|---|---|
| $60 | 1 octet | 6 |
Détail du dépilage :
- 1. SP := SP + 1
- 2. PCL := [$0100+SP] (poids faible)
- 3. SP := SP + 1
- 4. PCH := [$0100+SP] (poids fort)
- 5. PC := PC + 1
Exemple :
- JSR MaRoutine ; appel
- ; ... continue ici apres RTS ...
-
- MaRoutine:
- ; ... code ...
- RTS ; retour a l'appelant
Astuce : JMP indirect simule par PUSH + RTS :
RTI - Return from Interrupt (Retour d'interruption)
Dépile le registre d'état puis l'adresse de retour depuis la pile. Contrairement a RTS, RTI ne modifie PAS l'adresse dépilée (pas de +1), car lors d'une interruption, le PC exact est empile.
Opération : PULL P, PULL PC
Drapeaux affectes : tous (restaures depuis la pile)
| Opcode | Taille | Cycles |
|---|---|---|
| $40 | 1 octet | 6 |
Détail du dépilage :
- 1. SP := SP + 1
- 2. P := [$0100+SP] (registre d'état)
- 3. SP := SP + 1
- 4. PCL := [$0100+SP]
- 5. SP := SP + 1
- 6. PCH := [$0100+SP]
Exemple :
- ; Gestionnaire d'interruption IRQ
- GestionnaireIRQ:
- PHA ; sauvegarder A
- TXA
- PHA ; sauvegarder X
- TYA
- PHA ; sauvegarder Y
-
- ; ... traitement de l'interruption ...
-
- PLA
- TAY ; restaurer Y
- PLA
- TAX ; restaurer X
- PLA ; restaurer A
- RTI ; retourner de l'interruption
Remarques :
- RTI restaure complètement le registre P, y compris le drapeau I (Interrupt Disable)
- La différence entre RTS et RTI est importante : RTS ajoute 1 a l'adresse dépilée, RTI non. Utiliser l'un a la place de l'autre causerait une erreur d'un octet.
- Le drapeau B (Break) dans le P empile est positionne pour BRK et efface pour les interruptions matérielles
BRK - Break (Interruption logicielle)
Génère une interruption logicielle. Empile PC+2 et P sur la pile, positionne le drapeau I, et saute au vecteur d'interruption IRQ/BRK ($FFFE-$FFFF).
Opération :
|
PC := PC + 2 (pointe après BRK + octet de signature) PUSH PCH PUSH PCL PUSH P (avec B = 1) I := 1 PC := [$FFFE]:[$FFFF] |
Drapeaux affectes : I est positionne. B est positionne dans la copie empilée de P (mais pas dans P lui-même).
| Opcode | Taille | Cycles |
|---|---|---|
| Opcode : $00 | 1 octet* | 7 |
* Note : BRK est formellement une instruction de 1 octet, mais le PC empile pointe 2 octets APRES le BRK. L'octet suivant le BRK est considéré comme un "octet de signature" (padding byte) étant sauté. Cet octet peut être utilisé par le gestionnaire d'interruption pour identifier la raison du BRK.
Exemples :
- ; Interruption logicielle simple
- BRK ; declencher une interruption logicielle
- .BYTE $01 ; signature (optionnel, utilise par le handler)
-
- ; Dans le gestionnaire d'interruption, distinguer BRK de IRQ :
- GestionnaireIRQ:
- ; ... sauvegarder les registres ...
- PLA ; recuperer P de la pile
- PHA ; le remettre
- AND #$10 ; tester le bit B (Break)
- BNE EstBRK ; si B=1, c'est un BRK
- ; Sinon, c'est une IRQ materielle
- ; ...
- EstBRK:
- ; Traiter le BRK
- ; ...
Remarques :
- BRK utilise le même vecteur que IRQ ($FFFE-$FFFF)
- Pour distinguer BRK de IRQ, examiner le drapeau B dans la copie de P empilée sur la pile
- BRK est souvent utilise comme point d'arrêt (breakpoint) par les débogueurs et les moniteurs
- Certains systèmes utilisent BRK + signature comme appel système (l'octet de signature identifie le service)
- Sur le 6502 NMOS, si un NMI survient en même temps qu'un BRK, le BRK peut être "avale" (race condition connue)
Instructions de pile
Ces instructions empilent ou dépilent des valeurs sur la pile située en page 1 ($0100-$01FF).
PHA - Push Accumulator (Empiler A)
Empile le contenu de l'accumulateur sur la pile.
Opération : [$0100+SP] ← A, SP ← SP - 1
Drapeaux affectes : aucun
| Opcode | Taille | Cycles |
|---|---|---|
| $48 | 1 octet | 3 |
Exemple :
- PHA ; sauvegarder A sur la pile
PLA - Pull Accumulator (Depiler A)
Dépile une valeur de la pile dans l'accumulateur.
Opération : SP ← SP + 1, A ← [$0100+SP]
Drapeaux affectes : N, Z
| Opcode | Taille | Cycles |
|---|---|---|
| $68 | 1 octet | 4 |
Exemple :
- PLA ; restaurer A depuis la pile
Remarque : PLA affecte N et Z, contrairement a PHA.
PHP - Push Processor Status (Empiler P)
Empile le registre d'état du processeur sur la pile.
Opération : [$0100+SP] ← P (avec B=1), SP ← SP - 1
Drapeaux affectes : aucun
| Opcode | Taille | Cycles |
|---|---|---|
| $08 | 1 octet | 3 |
Remarque : PHP empile TOUJOURS P avec le drapeau B positionne a 1 et le bit 5 (inutilise) a 1.
PLP - Pull Processor Status (Dépiler P)
Dépile une valeur de la pile dans le registre d'état.
Opération : SP ← SP + 1, P ← [$0100+SP]
Drapeaux affectes : tous (restaures depuis la valeur dépilée)
| Opcode | Taille | Cycles |
|---|---|---|
| $28 | 1 octet | 4 |
Exemple :
- ; Sauvegarder et restaurer les drapeaux
- PHP ; sauvegarder P
- ; ... code qui modifie les drapeaux ...
- PLP ; restaurer P (tous les drapeaux)
Remarques :
- PLP restaure tous les drapeaux, y compris I et D
- Ceci peut être utilisé pour activer/désactiver les interruptions de manière atomique
- Les bits B (bit 4) et le bit 5 (inutilisé) sont ignorés par PLP et toujours lus comme 1
Exemple : sauvegarder X et Y via la pile :
- ; Le 6502 n'a pas de PHX/PHY (ajoutes sur le 65C02)
- ; Pour sauvegarder X :
- TXA ; A := X
- PHA ; empiler A (qui contient X)
- ; Pour restaurer X :
- PLA ; depiler dans A
- TAX ; X := A
- ; Idem pour Y avec TYA/PHA et PLA/TAY
Instructions de contrôle des drapeaux
Ces instructions modifient directement les drapeaux du registre d'état P. Elles sont en mode implicite (1 octet, 2 cycles).
CLC - Clear Carry Flag (Effacer la retenue)
Opération : C ← 0
| Opcode | Taille | Cycles |
|---|---|---|
| $18 | 1 octet | 2 |
Utilisation : OBLIGATOIRE avant ADC pour éviter une retenue parasite dans l'addition
Exemple :
SEC - Set Carry Flag (Positionner la retenue)
Opération : C ← 1
| Opcode | Taille | Cycles |
|---|---|---|
| $38 | 1 octet | 2 |
Utilisation : OBLIGATOIRE avant SBC pour éviter un emprunt parasite dans la soustraction.
Exemple :
- SEC
- LDA #$50
- SBC #$20 ; A = $30 (et non $2F si C etait 0)
CLD - Clear Decimal Mode (Desactiver le mode decimal)
Opération : D ← 0
| Opcode | Taille | Cycles |
|---|---|---|
| $D8 | 1 octet | 2 |
Utilisation : revenir en mode binaire après des calculs BCD, ou en début de programme pour s'assurer du mode binaire.
Exemple :
- CLD ; s'assurer que le mode binaire est actif
- ; ... code arithmetique normal ...
Remarque : le 6502 NMOS ne définit pas l'état du drapeau D après un RESET ou une IRQ. Il est recommande de faire CLD au début de tout programme et de tout gestionnaire d'interruption.
SED - Set Decimal Mode (Activer le mode décimal)
Opération : D ← 1
| Opcode | Taille | Cycles |
|---|---|---|
| $F8 | 1 octet | 2 |
Utilisation : activer le mode BCD pour ADC et SBC
Exemple :
Remarque : en mode BCD, seuls ADC et SBC sont affectes. Les autres instructions (INC, DEC, etc.) continuent a fonctionner en binaire.
CLI - Clear Interrupt Disable (Autoriser les interruptions)
Opération : I ← 0
| Opcode | Taille | Cycles |
|---|---|---|
| $58 | 1 octet | 2 |
Utilisation : re-autoriser les interruptions IRQ après les avoir désactivées.
Exemple :
- CLI ; autoriser les interruptions IRQ
Remarque : les interruptions NMI ne sont PAS affectées par le drapeau I. Elles sont toujours actives.
SEI - Set Interrupt Disable (Masquer les interruptions)
Opération : I ← 1
| Opcode | Taille | Cycles |
|---|---|---|
| $78 | 1 octet | 2 |
Utilisation : désactiver les interruptions IRQ pendant une section critique du code.
Exemple :
- SEI ; desactiver les interruptions IRQ
- ; ... section critique ...
- ; ... modifier des donnees partagees avec l'IRQ ...
- CLI ; re-autoriser les interruptions
CLV - Clear Overflow Flag (Effacer le débordement)
Opération : V ← 0
| Opcode | Taille | Cycles |
|---|---|---|
| $B8 | 1 octet | 2 |
Utilisation : effacer le drapeau de débordement. Rarement utilise en pratique.
Remarques :
- Il n'existe PAS d'instruction SEV (Set Overflow).
- Le drapeau V peut être positionné par le pin SO (Set Overflow) du processeur, utilise par certains périphériques (lecteur de disquette du Commodore 1541)
- V est automatiquement positionne par ADC/SBC en cas de débordement signe, et par BIT (bit 6 de M → V)
Résumé des instructions de contrôle des drapeaux :
| Instruction | Opcode | Opération | Utilisation principale |
|---|---|---|---|
| CLC | $18 | C ← 0 | Avant ADC |
| SEC | $38 | C ← 1 | Avant SBC |
| CLD | $D8 | D ← 0 | Mode binaire (début programme) |
| SED | $F8 | D ← 1 | Mode BCD |
| CLI | $58 | I ← 0 | Autoriser les IRQ |
| SEI | $78 | I ← 1 | Masquer les IRQ |
| CLV | $B8 | V ← 0 | Effacer le débordement |
Instruction NOP
NOP - No Operation (Pas d'opération)
Ne fait rien. Le processeur consomme du temps et de l'espace sans modifier l'état du processeur (aucun registre ni drapeau modifié).
Opération : aucune
Drapeaux affectes : aucun
| Opcode | Taille | Cycles |
|---|---|---|
| $EA | 1 octet | 2 |
Utilisations :
- Ajustement de la minuterie (chaque NOP consomme 2 cycles)
- Réserve d'espace pour des corrections futures (patcher du code avec des NOP)
- Remplacement d'instructions supprimées (NOP-out)
- Alignement de code
- Débogage
Exemples :
- ; Delai precis de 10 cycles
- NOP ; 2 cycles
- NOP ; 2 cycles
- NOP ; 2 cycles
- NOP ; 2 cycles
- NOP ; 2 cycles (total : 10 cycles)
-
- ; Patcher du code : remplacer un JSR par des NOP
- ; Avant : JSR $C000 (3 octets: $20 $00 $C0)
- ; Apres : NOP NOP NOP (3 octets: $EA $EA $EA)
Résumé et tableau récapitulatif
Le 6502 possède 56 instructions officielles reparties en 11 catégories. Voici le tableau récapitulatif complet :
Instructions de transfert de données (12 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| LDA | Charger A depuis la mémoire | N, Z |
| LDX | Charger X depuis la mémoire | N, Z |
| LDY | Charger Y depuis la mémoire | N, Z |
| STA | Entreposer A en mémoire | - |
| STX | Entreposer X en mémoire | - |
| STY | Entreposer Y en mémoire | - |
| TAX | Transférer A vers X | N, Z |
| TAY | Transférer A vers Y | N, Z |
| TXA | Transférer X vers A | N, Z |
| TYA | Transférer Y vers A | N, Z |
| TSX | Transférer SP vers X | N, Z |
| TXS | Transférer X vers SP | - |
Instructions arithmétiques (8 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| ADC | Addition avec retenue | N, V, Z, C |
| SBC | Soustraction avec retenue | N, V, Z, C |
| INC | Incrémenter la mémoire | N, Z |
| INX | Incrémenter X | N, Z |
| INY | Incrémenter Y | N, Z |
| DEC | Décrémenter la mémoire | N, Z |
| DEX | Décrémenter X | N, Z |
| DEY | Décrémenter Y | N, Z |
Instructions logiques (3 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| AND | ET logique avec A | N, Z |
| ORA | OU logique avec A | N, Z |
| EOR | OU exclusif avec A | N, Z |
Instructions de décalage/rotation (4 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| ASL | Décalage a gauche | N, Z, C |
| LSR | Décalage logique a droite | N, Z, C |
| ROL | Rotation a gauche via C | N, Z, C |
| ROR | Rotation a droite via C | N, Z, C |
Instructions de comparaison (4 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| CMP | Comparer A avec la mémoire | N, Z, C |
| CPX | Comparer X avec la mémoire | N, Z, C |
| CPY | Comparer Y avec la mémoire | N, Z, C |
| BIT | Tester des bits en mémoire | N, V, Z |
Instructions de branchement (8 instructions)
| Mnémonique | Description | Condition |
|---|---|---|
| BCC | Brancher si C = 0 | C = 0 |
| BCS | Brancher si C = 1 | C = 1 |
| BEQ | Brancher si Z = 1 (égal) | Z = 1 |
| BNE | Brancher si Z = 0 (différent) | Z = 0 |
| BMI | Brancher si N = 1 (négatif) | N = 1 |
| BPL | Brancher si N = 0 (positif) | N = 0 |
| BVC | Brancher si V = 0 | V = 0 |
| BVS | Brancher si V = 1 | V = 1 |
Instructions de saut et d'appel (5 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| JMP | Saut inconditionnel | - |
| JSR | Appel de sous-programme | - |
| RTS | Retour de sous-programme | - |
| RTI | Retour d'interruption | tous |
| BRK | Interruption logicielle | I |
Instructions de pile (4 instructions)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| PHA | Empiler A | - |
| PLA | Dépiler A | N, Z |
| PHP | Empiler P | - |
| PLP | Depiler P | tous |
Instructions de contrôle des drapeaux (7 instructions)
| Mnémonique | Description | Opération |
|---|---|---|
| CLC | Effacer la retenue | C ← 0 |
| SEC | Positionner la retenue | C ← 1 |
| CLD | Désactiver le mode décimal | D ← 0 |
| SED | Activer le mode décimal | D ← 1 |
| CLI | Autoriser les interruptions | I ← 0 |
| SEI | Masquer les interruptions | I ← 1 |
| CLV | Effacer le débordement | V ← 0 |
Instruction NOP (1 instruction)
| Mnémonique | Description | Drapeaux |
|---|---|---|
| NOP | Pas d'opération | - |
Total : 56 instructions, 151 opcodes valides (sur 256 possibles)
Les 105 opcodes restants sont non documentes ("illegal opcodes"). Certains produisent des effets utiles exploites par les programmeurs.
Comparaison avec d'autres processeurs :
| Processeur | Instructions | Opcodes valides | Registres |
|---|---|---|---|
| MOS 6502 | 56 | 151 | 3 (A,X,Y) |
| Zilog Z80 | 158 | 694 (avec CB/DD) | 14 |
| Intel 8080 | 78 | 244 | 7 |
| Motorola 6800 | 72 | 197 | 2 (A,B) |
| Motorola 6809 | 86 | ~210 | 6 |
| Motorola 68000 | 56+ | ~140 base | 16 (D0-D7,A0-A7) |
| Intel 8086 | ~100 | ~300 | 8 GPR |
Le 6502, avec ses 56 instructions, est l'un des processeurs les plus simples de sa génération. Malgré ce minimalisme, la richesse de ses modes d'adressage (13 modes) et l'utilisation créative de la page zéro permettent d'écrire du code compact et performant.