TP1 Assembleur 6800/6811

Addition simple (a + b)

Q1.1 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

Q1.2 Calculs préalables

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

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

Q1.3 Contenu de la mémoire après assemblage

0000

opcode ldaa

0001

adr high

0002

adr low

0003

opcode adda

0004

adr high

0005

adr low

0006

opcode staa

0007

adr high

0008

adr low

00B0

a = 25

00B1

b = 47

00B2

resultat = 0

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

Q1.4 Identification des éléments

É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)

Q1.5 Exécution pas à pas

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₁₆

✅ Q1.6 Oui, le résultat (48₁₆ = 72₁₀) correspond à la prédiction !

Soustraction (x - y)

Q2.1 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

Q2.2 Prédiction

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₁₆

Q2.3 Exécution normale

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

✅ Après l'exécution du programme diff= 63₁₀ = 3F₁₆

⚠️ Q2.4 Cas limite : x = 50, y = 80

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₁₀

⚠️ Q2.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 ⚠️

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

Q3.1 Réflexion sur l'algorithme

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

Q3.2 Code source assembleur

        .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

Q3.3 Évolution du registre A

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₁₆

Q3.4 Taille du programme en mémoire

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

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

Q4.1 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

Q4.2 Prédiction manuelle

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₁₆

Q4.3 Évolution des registres

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

✅ Résultat final : somme = 45₁₀ = 2D₁₆

Q4.4 Taille du programme en mémoire

Calcul de la taille :
• ldaa a → 3 octets (B6 00 E0)
• adda b → 3 octets (BB 00 E1)
• ldab c → 3 octets (F6 00 E2)
• addb d → 3 octets (FB 00 E3)
• stab temp → 3 octets (F7 00 E4)
• suba temp → 3 octets (B0 00 E4)
• staa resultat → 3 octets (B7 00 E5)
━━━━━━━━━━━━━━━━━━ TOTAL : 21 octets

📊 Occupation mémoire :
• Instructions : 21 octets (de 0000 à 0014)
• Données : 6 octets (de 00E0 à 00E5)
• Total : 27 octets

🤔 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 ✓

🖥️ Correction TP1 Assembleur 6800

Addition simple (a + b)

Q1.1 Code source assembleur

Q1.2 Calculs préalables

Q1.3 Contenu de la mémoire après assemblage

Q1.4 Identification des éléments

Q1.5 Exécution pas à pas

Soustraction (x - y)

Q2.1 Code source assembleur

Q2.2 Prédiction

Q2.3 Exécution normale

⚠️ Q2.4 Cas limite : x = 50, y = 80

Tableau récapitulatif des cas

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

Q3.1 Réflexion sur l'algorithme

Q3.2 Code source assembleur

Q3.3 Évolution du registre A

Q3.4 Taille du programme en mémoire

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

Q4.1 Code source assembleur

Q4.2 Prédiction manuelle

Q4.3 Évolution des registres

Q4.4 Taille du programme en mémoire

🤔 Pourquoi une variable temporaire ? (Question 4.5)

Schéma du processus

Tableau récapitulatif

Vue d'ensemble des 4 exercices

Instructions utilisées et leurs opcodes

Points clés à retenir

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₁₆

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