Correction détaillée - Exercices MC6809
Préparation examen
Introduction
Ce document corrige les exercices 6 et 7 pas à pas. Chaque instruction est commentée, et
l’effet sur les registres et la mémoire est expliqué. À la fin, une méthode générale pour réussir
ce type d’exercice en examen est donnée.
1 Exercice 6
1.1 Données
Programme stocké en mémoire de $C000 à $C006 :
Adresse Octet
$C000 9E
$C001 00
$C002 A6
$C003 02
$C004 4A
$C005 48
$C006 3F
État initial partiel de la mémoire :
Adresse Contenu
$0000 00
$0001 01
$0002 3F
$0003 CE
$0004 27
$0005 DF
1.2 Question a : Désassembler et commenter
1.2.1 Adresse $C000 : 9E 00
— 9E dans la table des instructions (page 5 du PDF) correspond à LDX (Load Index
Register) en mode direct.
— Le mode direct prend un opérande de 8 bits : ici 00.
— L’adresse effective est donc $0000.
— Commentaire : On charge le registre X avec le mot de 16 bits situé aux adresses $0000
et $0001.
Lecture en mémoire :
1
— $0000 = 00
— $0001 = 01
Donc X reçoit $0001.
1.2.2 Adresse $C002 : A6 02
— A6 = LDA (Load Accumulator A) en mode indexé.
— Le post-octet 02 = 0000 0010.
— Bits b6 b5 = 00 → registre X.
— Bits b4..b0 = 00010 → déplacement codé sur 5 bits = +2.
— Adresse effective = X + 2 = $0001 + 2 = $0003.
Lecture : mémoire[$0003] = CE. Donc A = $CE.
1.2.3 Adresse $C004 : 4A
— 4A = DECA (DECrement A) – mode inhérent.
— A = $CE - 1 = $CD.
— Le bit Z (Zero) devient 0 (car résultat non nul).
— Le bit N (Negative) devient 1 (car $CD a son bit de poids fort = 1).
1.2.4 Adresse $C005 : 48
— 48 = ASLA (Arithmetic Shift Left A) – mode inhérent.
— On décale A d’un bit vers la gauche.
— $CD = 1100 1101 → décalé = 1001 1010 = $9A.
— Le bit C (Carry) prend la valeur du bit sorti : ici le bit b7 = 1 → C = 1.
— A = $9A.
1.2.5 Adresse $C006 : 3F
— 3F = SWI (SoftWare Interrupt) – interruption logicielle.
— Le programme s’arrête ou passe en routine d’interruption.
1.3 Résumé du désassemblage
C000: 9E 00 LDX $00 ; X = [0000][0001] = 0001
C002: A6 02 LDA 2,X ; A = [X+2] = [0003] = CE
C004: 4A DECA ; A = CD
C005: 48 ASLA ; A = 9A, C=1
C006: 3F SWI ; interruption
1.4 Question b : État après exécution
— Accumulateur A : $9A
— Registre X : $0001
— Bit C : 1
— Bit Z : 0 (car A n’est pas nul)
2
2 Exercice 7
2.1 Données
Code hexadécimal : 8E 10 00 10 8E 20 00 A6 84 E6 A4 3D FD 30 00 3F
2.2 Désassemblage et commentaires
2.2.1 Adresse $ ? ? ? ? (début) : 8E 10 00
— 8E = LDS (Load Stack Pointer) en mode immédiat 16 bits.
— Opérande : 10 00 = $1000.
— Commentaire : On charge le pointeur de pile S avec $1000.
2.2.2 8E 20 00
— Encore 8E = LDS immédiat.
— Opérande : 20 00 = $2000.
— Commentaire : S = $2000 (écrase la valeur précédente).
2.2.3 A6 84
— A6 = LDA indexé.
— Post-octet 84 = 1000 0100.
— Bits b6 b5 = 00 → registre X.
— Attention : b7=1, b4=0 → c’est un mode particulier.
— En réalité, 84 = 10000100 = mode [R] (indirect via R). Non, vérifions Table 2 page 8 :
1RR00100 = ,R (indirect). Donc adresse effective = [X].
— On suppose X inconnu. Si X = $2000, alors A = [$2000].
2.2.4 E6 A4
— E6 = LDB indexé.
— Post-octet A4 = 1010 0100.
— Bits b6 b5 = 01 → registre Y.
— Mode = [Y] (indirect).
— B = [Y].
2.2.5 3D
— 3D = MUL (Multiplier A par B).
— Résultat 16 bits dans D (A et B concaténés).
— A × B → D. A = partie haute, B = partie basse après multiplication ? Non, sur 6809 :
A × B → D (D = A :B).
2.2.6 FD 30 00
— FD = STD (Store D) en mode étendu.
— Adresse : 30 00 = $3000.
— On stocke D (A :B) à $3000 et $3001.
3
2.2.7 3F
— 3F = SWI (interruption logicielle).
2.3 Résumé du désassemblage
8E 10 00 LDS #$1000 ; S = 1000
8E 20 00 LDS #$2000 ; S = 2000
A6 84 LDA [X] ; A = [[X]]
E6 A4 LDB [Y] ; B = [[Y]]
3D MUL ; D = A × B
FD 30 00 STD $3000 ; [3000]=A, [3001]=B
3F SWI
2.4 Fonction du programme
Ce programme :
1. Initialise le pointeur de pile (inutilement deux fois).
2. Charge A et B depuis des adresses pointées par X et Y (indirect).
3. Multiplie A par B.
4. Stocke le résultat 16 bits en $3000-$3001.
5. Se termine par une interruption.
3 Méthode générale pour réussir ces exercices
3.1 Pour désassembler
1. Prendre le premier octet (opcode).
2. Chercher dans la table des instructions (pages 5-7 du PDF).
3. Identifier le mode d’adressage :
— Immédiat : opérande après l’opcode.
— Direct : 1 octet adresse.
— Étendu : 2 octets adresse.
— Indexé : 1 post-octet après opcode.
— Inhérent : pas d’opérande.
4. Lire le(s) octet(s) suivant(s) selon le mode.
5. Écrire le mnémonique.
6. Passer à l’octet suivant.
3.2 Lire un post-octet indexé (Table 2 page 8)
— Bits 6-5 : registre (00=X, 01=Y, 10=U, 11=S ou PC selon cas).
— Bits 4-0 : mode d’adressage.
— Exemples :
— 00000101 = offset nul sur X → ,X
— 10000100 = indirect sur X → [X]
— 00100000 = ,R+ (incrément après)
4
3.3 Pour simuler l’exécution
1. Noter l’état initial des registres (souvent donné ou supposé nul).
2. Exécuter chaque instruction dans l’ordre.
3. Mettre à jour les registres et la mémoire.
4. À la fin, donner l’état demandé.
3.4 Instructions à connaître absolument
Opcode Mnémonique Signification
86 LDA # Charger A immédiat
96 LDA Charger A direct
A6 LDA Charger A indexé
B6 LDA Charger A étendu
97 STA Stocker A direct
C6 LDB # Charger B immédiat
8E LDS # Charger S immédiat
9E LDX Charger X direct
4A DECA Décrémenter A
48 ASLA Décalage gauche A
3D MUL Multiplier A×B
FD STD Stocker D étendu
3F SWI Interruption
01 NOP Ne rien faire
39 RTS Retour de sous-programme
4 Conclusion
Avec ces explications et la méthode pas à pas, vous êtes prêt pour l’examen. Entraînez-
vous sur des petits codes en utilisant systématiquement les tables fournies. La clé est de lire
l’opcode, identifier le mode, puis simuler.