Correction TP1 Assembleur 6800

1

Addition simple (a + b)

Code source assembleur

        .org $0000
        ldaa a              ; Charger a dans A
        adda b              ; Ajouter b à A
        staa resultat       ; Stocker A dans resultat
        
        .org $00B0
a       .byte 25
b       .byte 47
resultat .byte 0

Calculs préalables (Question 1.2)

Résultat en décimal : 25 + 47 = 72₁₀ Conversion en hexadécimal : 72 ÷ 16 = 4 reste 8 72₁₀ = 48₁₆

✅ Réponse attendue : 72₁₀ = 48₁₆

Contenu de la mémoire après assemblage (Question 1.3)

0000

B6

opcode ldaa

0001

00

adr high

0002

B0

adr low

0003

BB

opcode adda

0004

00

adr high

0005

B1

adr low

0006

B7

opcode staa

0007

00

adr high

0008

B2

adr low

00B0

19

a = 25

00B1

2F

b = 47

00B2

00

resultat = 0

📝 Note : Format mémoire complet
0000: B6 00 B0 BB 00 B1 B7 00 B2
00B0: 19 2F 00

Identification des éléments (Question 1.4)

Élément	Valeur hexadécimale	Explication
Opcode ldaa	B6	Code machine pour ldaa (mode extended)
Opcode adda	BB	Code machine pour adda (mode extended)
Opcode staa	B7	Code machine pour staa (mode extended)
Adresse de a	00 B0	Adresse sur 16 bits (2 octets)
Adresse de b	00 B1	Adresse sur 16 bits (2 octets)
Adresse de resultat	00 B2	Adresse sur 16 bits (2 octets)
Taille instruction	3 octets	Opcode (1) + Adresse (2)

Exécution pas à pas (Question 1.5)

Après l'instruction	Registre A (hexa)	Registre A (décimal)	Explication
`ldaa a`	19	25	A reçoit le contenu de [00B0] = 25
`adda b`	48	72	A = 19 + 2F = 48 (25 + 47 = 72)
`staa resultat`	48	72	Mémoire[00B2] reçoit 48₁₆

✅ Question 1.6 : Oui, le résultat (48₁₆ = 72₁₀) correspond à la prédiction !

2

Soustraction (x - y)

Code source assembleur

        .org $0000
        ldaa x
        suba y              ; Instruction de soustraction
        staa diff
        
        .org $00C0
x       .byte 100
y       .byte 37
diff    .byte 0

Prédiction (Question 2.2)

Résultat en décimal : 100 - 37 = 63₁₀ Conversion en hexadécimal : 63 ÷ 16 = 3 reste 15 (F) 63₁₀ = 3F₁₆

✅ Réponse attendue : 63₁₀ = 3F₁₆

Exécution normale

Instruction	A (hexa)	A (décimal)
`ldaa x`	64	100
`suba y`	3F	63

⚠️ Cas limite : x = 50, y = 80 (Question 2.4)

Calcul mathématique : 50 - 80 = -30₁₀ Mais en binaire 8 bits (non signé) : 50₁₀ = 0011 0010₂ = 32₁₆ 80₁₀ = 0101 0000₂ = 50₁₆ 50₁₆ - 32₁₆ = ? → Il faut "emprunter" (borrow) → Résultat : E2₁₆ = 226₁₀

⚠️ Question 2.5 - Explication :

Le registre A ne peut stocker que des valeurs non signées de 0 à 255.

Quand on soustrait 80 de 50, on obtient un résultat négatif qui ne peut pas être représenté directement.

Le processeur effectue une soustraction modulo 2⁸ = 256 :
50 - 80 = -30 ≡ 226 (mod 256)

Vérification : 226 - 256 = -30 ✓

Le résultat E2₁₆ (226₁₀) représente donc -30 en complément à 2ⁿ (ici n=8 donc 2⁸=256).

💡 Pour identifier ce résultat : Les flags Carry et Negative seront positionnés à 1, indiquant une retenue et un résultat négatif .

Tableau récapitulatif des cas

x	y	Résultat mathématique	Résultat 8 bits (hexa)	Résultat 8 bits (décimal)
100	37	63	3F	63 ✓
50	80	-30	E2	226 ⚠️
0	1	-1	FF	255 ⚠️

3

Calcul à trois opérandes (a + b + c)

Réflexion sur l'algorithme (Question 3.1)

Instructions nécessaires :
• 1 × ldaa (charger la première valeur)
• 2 × adda (ajouter les deux autres valeurs)
• 1 × staa (stocker le résultat)

Total : 4 instructions minimum

Code source assembleur (Question 3.2)

        .org $0000
        ldaa a              ; A ← 15
        adda b              ; A ← A + 28 = 43
        adda c              ; A ← A + 42 = 85
        staa somme          ; somme ← 85
        
        .org $00D0
a       .byte 15            ; 0F en hexa
b       .byte 28            ; 1C en hexa
c       .byte 42            ; 2A en hexa
somme   .byte 0

Évolution du registre A (Question 3.3)

Après l'instruction	Valeur de A (hexa)	Valeur de A (décimal)	Calcul
`ldaa a`	0F	15	Chargement de a
`adda b`	2B	43	0F + 1C = 2B (15 + 28 = 43)
`adda c`	55	85	2B + 2A = 55 (43 + 42 = 85)
`staa somme`	55	85	A inchangé, mémoire mise à jour

✅ Résultat final : somme = 85₁₀ = 55₁₆

Taille du programme en mémoire (Question 3.4)

Calcul de la taille : • ldaa a → 3 octets (B6 00 D0) • adda b → 3 octets (BB 00 D1) • adda c → 3 octets (BB 00 D2) • staa s → 3 octets (B7 00 D3) ━━━━━━━━━━━━━━━━━━ TOTAL : 12 octets

📊 Occupation mémoire :
• Instructions : 12 octets (de 0000 à 000B)
• Données : 4 octets (de 00D0 à 00D3)
• Total : 16 octets

4

Utilisation des deux registres : (a+b)-(c+d)

Code source assembleur

        .org $0000
        ; Calcul de (a + b) dans A
        ldaa a
        adda b
        
        ; Calcul de (c + d) dans B
        ldab c              ; Charger c dans B
        addb d              ; Ajouter d à B
        
        ; Soustraction A - B
        stab temp           ; Sauvegarder B en mémoire
        suba temp           ; A ← A - [temp]
        staa resultat
        
        .org $00E0
a       .byte 50
b       .byte 30
c       .byte 20
d       .byte 15
temp    .byte 0             ; Variable temporaire nécessaire
resultat .byte 0

Prédiction manuelle (Question 4.2)

Calcul de (a + b) : 50 + 30 = 80₁₀ = 50₁₆ Calcul de (c + d) : 20 + 15 = 35₁₀ = 23₁₆ Résultat final : 80 - 35 = 45₁₀ = 2D₁₆

✅ Réponse attendue : 45₁₀ = 2D₁₆

Évolution des registres (Question 4.3)

Instruction	A (hexa)	B (hexa)	temp (hexa)	Explication
Initial	00	00	00	État initial
`ldaa a`	32	00	00	A ← 50₁₀
`adda b`	50	00	00	A ← 50 + 30 = 80₁₀
`ldab c`	50	14	00	B ← 20₁₀
`addb d`	50	23	00	B ← 20 + 15 = 35₁₀
`stab temp`	50	23	23	temp ← B
`suba temp`	2D	23	23	A ← 80 - 35 = 45₁₀
`staa resultat`	2D	23	23	resultat ← A

🤔 Pourquoi une variable temporaire ? (Question 4.5)

Problème : Il n'existe pas d'instruction suba B dans le MC6800 !

Instructions disponibles :
• suba adresse - Soustraire le contenu d'une ADRESSE MÉMOIRE
• Mais PAS suba B - Soustraire directement le registre B

Solution :
1. Sauvegarder B en mémoire : stab temp
2. Soustraire depuis la mémoire : suba temp

💡 Limitation architecturale :
Le MC6800 ne peut pas effectuer d'opérations arithmétiques directement entre deux registres. Toutes les opérations arithmétiques se font entre un registre et la MÉMOIRE.

📚 Instructions inexistantes dans le MC6800 :
• adda B ❌
• suba B ❌
• addb A ❌
• subb A ❌

✅ Instructions valides :
• adda adresse ✓
• suba adresse ✓
• addb adresse ✓
• subb adresse ✓

Schéma du processus

┌─────────────────────────────────────────────┐
│  Registres                                  │
│  ┌──────┐         ┌──────┐                 │
│  │  A   │         │  B   │                 │
│  │  50  │         │  23  │                 │
│  └──────┘         └──────┘                 │
│     ↓                 ↓                     │
│     │         ┌───────┘                     │
│     │         │                             │
│     │    ┌────▼────┐                        │
│     │    │  stab   │ Étape 1: Sauvegarder B│
│     │    └────┬────┘                        │
│     │         │                             │
│     │         ▼                             │
│     │    ┌─────────┐                        │
│     │    │ temp=23 │ Mémoire temporaire    │
│     │    └─────────┘                        │
│     │         │                             │
│     │         │                             │
│     └─────────┴──► suba temp                │
│              Étape 2: A ← A - [temp]        │
│              Résultat: A = 2D (45₁₀)        │
└─────────────────────────────────────────────┘

📊

Tableau récapitulatif

Vue d'ensemble des 4 exercices

Exercice	Opération	Octets code	Octets données	Résultat
Ex 1	a + b	9 octets	3 octets	72₁₀ = 48₁₆
Ex 2	x - y	9 octets	3 octets	63₁₀ = 3F₁₆
Ex 3	a + b + c	12 octets	4 octets	85₁₀ = 55₁₆
Ex 4	(a+b)-(c+d)	21 octets	6 octets	45₁₀ = 2D₁₆

Instructions utilisées et leurs opcodes

Instruction	Opcode (Extended)	Taille totale	Cycles
`ldaa adresse`	B6	3 octets	5 cycles
`ldab adresse`	F6	3 octets	5 cycles
`staa adresse`	B7	3 octets	6 cycles
`stab adresse`	F7	3 octets	6 cycles
`adda adresse`	BB	3 octets	5 cycles
`addb adresse`	FB	3 octets	5 cycles
`suba adresse`	B0	3 octets	5 cycles

Points clés à retenir

✅ Architecture du MC6800 :
• Processeur 8 bits avec bus d'adresses 16 bits
• Deux registres accumulateurs : A et B
• Instructions en mode EXTENDED : 3 octets (opcode + adresse 16 bits)

✅ Limitations importantes :
• Pas d'opérations directes entre registres
• Capacité limitée à 255 sur 8 bits (risque d'overflow)
• Nécessité de variables temporaires pour certaines opérations

✅ Conversions :
• Toujours vérifier les conversions décimal ↔ hexadécimal
• Prévoir les cas de dépassement de capacité
• Utiliser les flags (Carry, Negative, Overflow, etc.) pour détecter la signification des résultats