Cours 03

Assembleur
Introduction à l’assembleur x86

Cours 03
Plan de la séance
Architecture x86 et IA-32
Assembleur IA-32
Déclaration des données
Modes d'adressage
Branchements
Exemples et exercices
Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 2

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements

Architecture x86
• Les architectures x86 ont été développé par Intel de 1976 à 2003
o 8086 (8 bits) – 1e génération
o 80386 (32 bits) – 3e génération – IA-32
o 80486 (32 bits) – 4e génération – IA-32 – pipelinage et cache
o Pentium (32 bits) – 5e génération – IA-32 – Superscalaire
o Pentium Pro (32 bits) – 6e génération – IA-32 – Extension d’adresses physiques
• L’IA-32 correspond à la version 32 bits de l’architecture x86
• Intel garantit la rétrocompatibilité de ses processeurs.

Architecture IA-32
• IA-32 pour architectures 32 bits
o Il s’agit d’une architecture abstraite
o Elle couvre les processeurs allant du 80386, jusqu’au Pentium 4…
o Elle a depuis été etendue à 64 bits: x86-64 / AMD64 (IA-64 est différent)

Architecture IA-32
• 8 registres 32-bits directement accessibles
o eax, ebx, ecx, edx, esi, edi utilisables
o ebp souvent utilisé comme « block pointer » (variables locales)
o esp pointeur de pile (pointe sur le dernier élément empilé)
• Un registre avec les indicateurs (eflags)
o retenue, débordement, signe, etc.
• Un compteur de programme (eip; pour « instruction pointer »)

Architecture IA-32
• 6 registres de segments (pas utilisés dans ce cours)
• Unité virgule flottante
o 8 registres de 80 bits accessibles comme une pile
o Registres de contrôle et de statut
• Unités MMX/SSE/SSE2/3D-Now …

Architecture IA-32
• Registres « généraux » 8 bits, 16 bits et 32 bits
o EAX<31..0> eax
o AX<15..0> := EAX<31..0>
ax
o AH<7..0> := EAX<15..8>
o AL<7..0> := EAX<7..0> ah al
• Pareil pour les quatre premiers registres 31 16 15 8 7 0
o eax, ax, ah, al

o ebx, bx, bh, bl
o ecx, cx, ch, cl
o edx, dx, dh, dl

Architecture IA-32 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
• Indicateurs (eflags) - NT IOPL OF DF IF TF SF ZF - AF - PF - CF
― CF: carry; retenue/emprunt; débordement non signé

― PF: parity; vrai si le nombre de bits à 1 est pair
― AF: auxiliary carry; pour le BCD
― ZF: zero; vrai si le résultat est zéro
― SF: sign; vrai si le résultat est négatif
― DF: direction (DF = faux → inc; DF = vrai → dec)
― OF: overflow; débordement signé

15 0
Architecture IA-32
31 0 CS - code
EAX DS - data Registres select –
EBX SS - stack Pointeurs qui identifient un segment
dans la mémoire – non utilisés dans
ECX ES - data
EDX FS - data
ESI GS - data
EDI 31 0
EBP – block pointer EFLAGS – plusieurs flag état, un flag ctrl
ESP – stack pointer EIP – Pointeur instructions - PC
Registres usage général Registres état et contrôle

Exercice 1:
Quelle est la différence entre x86 et IA-32?

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements

Assembleur IA-32
Types d’instructions
Il existe trois types d’instructions
• Déplacement de données
- Registre-registre
- Registre<- mémoire
- Mémoire <- registre
• Operation arithmetiques/logiques (UAL)
- add, sub, shift, and
• Branchement
- jmp, j?, call, ret

Assembleur IA-32
Type de machine
IA-32 est une architecture Register-Memory
• Il est possible d’additionner un registre et une valeur en mémoire
• Il est permis de mettre le résultat de l’addition en mémoire
• Il est n’est pas permis que la source et la destination d’une addition soient en mémoire

Assembleur IA-32
Syntaxe
Il existe deux syntaxes de l’IA-32:
Intel et AT&T
Syntaxe Intel:
add eax ebx # add dst src : eax  eax + ebx
Syntaxe AT&T:
add %ebx %eax # add src dst : eax  eax + ebx
Dans ce cours, nous utiliserons la syntaxe AT&T pour les compilateur GNU

Assembleur IA-32
Directives pour les segments de données et instructions
# directive on est dans le segment des données
.data
val:
.word 10, -14, 30 # trois mots
# on est dans le segment des instructions)

.text
.globl main # main est publique
main:
add %ebx %eax # addition

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements

Étiquette (label)
Étiquettes
# directive on est dans le segment données
.data
val:
.word 10, -14, 30 # trois mots
Valeurs
# on est dans le segment texte (instructions)
Type .text
.global main # main est publique
main:
add %ebx %eax # addition

Types
• Byte = 1 octet (8 bits)
• Word = 2 octets (16 bits)
• Doubleword (dword) = 4 octets (32 bits)
• Quadword (qword) = 8 octets (64 bits)
• Entiers non-signés de N bits, [0 , 2N-1]
• Entiers signées de N bits, [-2N-1 , 2N-1-1]
– En complément à 2
• Float = 4 octets (32 bits)
• Double = 8 octets (64 bits)
• Chaine de caractères

Notes sur la représentation en virgule flottante:
• Standardisé par l’IEEE: IEEE-754 r2008
• Triplet signe, exposant, mantisse: (s, e, m)
• Sauf exceptions, la valeur d’un nombre machine Xfp est donnée par la relation Xfp = (-1)s × m × 2e
• La mantisse est normalisée: 1.0 ≤ m < 2.0, i.e. m = 1.f,
• Seul f est sauvegardé
• L’exposant est signé. Le nombre signé s’obtient par un calcul de biais: e = eb - biais
• eb est sauvegardé
• eb = 0 ou eb = emax indiquent des exceptions, notamment eb = 0, f = 0 => Xfp = 0.0

Notes sur la représentation en virgule flottante: (suite)
• En simple précision: eb est web = 8 bits, f est 23 bits, biais = 127 (2web-1 - 1)
• En double précision: eb est web = 11 bits, f est 52 bits, biais = 1023 (2web-1 - 1)
• Exemples:
+2.5 est codé 0x40200000 en simple précision, 0x4004000000000000 en double précision
• Ressource en ligne:
https://gregstoll.com/~gregstoll/floattohex/

Étiquettes
• Les noms devant les « : » se nomment étiquettes
• La valeur de l’étiquette définie avec « : » est l’adresse présente
• Utilisées pour la déclaration des fonctions

Étiquettes
• Symboliques – ASCII – doivent être définies seulement une fois
.equ une_etiquette, 123 # une_etiquette = 123
• « . » est l’adresse présente
.equ une_autre, . # équivalent à « une_autre: »
• « .globl étiquette » pour la rendre publique
.globl main # main peut être appelée par l’usager
• Numériques – une chiffre entre 0 et 9
• Utilisée seulement pour référence locale
• Peuvent être redéfinies

Étiquettes
• Une étiquette est une constante
– Peut être utilisée partout où on peut entrer une valeur immédiate
– Sa valeur réelle connue à l’exécution, selon l’adresse du programme
• On ne peut pas écrire étiquette1+étiquette2, ni étiquette1*val
– étiquette1-étiquette2 est permis
– étiquette1-étiquette2 est connu à la compilation si déclarés dans le même fichier
– Il est permis d’écrire (étiquette1-étiquette2)*val

.data # espace initialisé, lisible, écrivable
# Si cet espace commence à 0x1000
unbyte: # unbyte = 0x1000
.byte 9, 8, 0b111 # M[0x1000] = 9, M[0x1001] = 8,
# M[0x1002] = 1112
unword: # unword = 0x1003
.word 1, 2, 10%3 # M16[0x1003] = 1, M16[0x1005] = 2,
# M16[0x1007] = mod(10, 3) = 1
unshort: # unshort = 0x1009
.short 0x9C, 077 # M16[0x1009] = 9C16, M16[0x100B] = 77(8)
unentier: # unentier = 0x100D
.int 52+4, unword-2 # M32[0x100D] = 56,
# M32[0x1011] = 0x1003-2 = 0x1001
.float 12.54 # M32[1015] = 12.54 en IEEE-754 sur 32-bits, soit 0x4148a3d7

.double 67.34 # M64[1019] = 67.34 en IEEE-754 sur 64-bits, soit 0x4050d5c28f5c28f6

Exercice 2:
Considérez le code suivant. En supposant que la section data débute à l’adresse
hexadécimale 0x1000, donnez le contenu des octets allant de x01000 à 0x1013.
.data # 0x1000
poly:
.qword 10, 041
mtl:
.short 1, 0xAA

Exercice 2:
Considérez le code suivant. En supposant que la section data débute à l’adresse
hexadécimale 0x1000, donnez le contenu des octets allant de x01000 à 0x1013.
.data # 0x1000
poly: 3 2 1 0
.qword 10, 041 0x1000 0x00 0x00 0x00 0x0A
mtl: 0x1004 0x00 0x00 0x00 0x00
.short 1, 0xAA
0x1008 0x00 0x00 0x00 0x21
0x100C 0x00 0x00 0x00 0x00
0x1010 0x00 0xAA 0x00 0x01

Exercice 3:
Considérez le code suivant. Donnez la valeur des étiquettes poly et mtl.
.data # 0x1000
poly:
.qword 10, 041
mtl:
.short 1, 0xAA

Exercice 3:
Considérez le code suivant. Donnez la valeur des étiquettes poly et mtl.
.data # 0x1000
poly: # 0x1000
.qword 10, 041 3 2 1 0
mtl: # 0x1010 0x1000 0x00 0x00 0x00 0x0A
.short 1, 0xAA
0x1004 0x00 0x00 0x00 0x00
0x1008 0x00 0x00 0x00 0x21
0x100C 0x00 0x00 0x00 0x00
0x1010 0x00 0xAA 0x00 0x01

Exercice 4:
Quel est le word à l’adresse a+3?
a:
.byte 0xAA, 0x22, 0x24, 0x5C, 0x6E

Exercice 4:
Quel est le word à l’adresse a+3?
a:
.byte 0xAA, 0x22, 0x24, 0x5C, 0x6E
0x6E5C

Exercice 5:
Soit le code assembleur suivant. En supposant que la section .data débute à
l’adresse hexadécimale 0x1000, donnez la valeur de taille.
.data
debut_data:
var1:
.byte 8, 9, 10, 11
var2:
.int 0x234
.word 0x5678, 256
.equ taille, fin_data – var2
fin_data:

Exercice 5:
Soit le code assembleur suivant. En supposant que la section data débute à
l’adresse hexadécimale 0x1000, donnez la valeur de taille.
3 2 1 0
.data
0x1000 0x0B 0x0A 0x09 0x08
debut_data:
var1: 0x1004 0x00 0x00 0x02 0x34
.byte 8, 9, 10, 11
0x1008 0x01 0x00 0x56 0x78
var2:
.int 0x234
.word 0x5678, 256 var1 = 0x1000,
.equ taille, fin_data – var2 var2 = 0x1004,
fin_data = 0x100C
fin_data:
taille = fin_data – var2
= 0x100C – 0x1004 = 0x8 = 8

Exercice 6:
Donnez en hexadécimal la valeur des octets aux adresses 0x1002 et 0x1006,
sachant que la section .data débute à l’adresse 0x1000.
.data # 0x1000
.float 1.5
.double 1.5

Exercice 6:
Donnez en hexadécimal la valeur des octets aux adresses 0x1002 et 0x100A,
sachant que la section .data débute à l’adresse 0x1000.
.data # 0x1000 3 2 1 0
.float 1.5 0x3FC00000
0x1000 0x3F 0xC0 0x00 0x00
.double 1.5 0x3FF8000000000000
0x1004 0x00 0x00 0x00 0x00
0x1008 0x3F 0xF8 0x00 0x00

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements
Boucles

Modes d’adressage
Types d’opérande
― Immédiate (constante) $12 # c = 12
― Registre %eax # R[0]
― Adressage direct 12 # M[12]
― Mémoire indexé 12(%eax, %ebx, 4) # M[12 + %eax + 4 x %ebx]
Éléments omis à 0 (k=1) 12(, %ebx, 4) # M[12 + 4 x %ebx]

Modes d’adressage
Suffixes
Les suffixes b (byte), w (word) et l (long) permettent de spécifier le type
de donnée sur lequel l’instruction agit:
addw $4, 1234 # M16[1234]  M16[1234] + 4

addl $4, 1234 # M32[1234]  M32[1234] + 4

Modes d’adressage
Exercice 7:
Donnez la valeur des octets aux adresses 0x1002 et 0x1006 à la fin de l’exécution
de ce programme, sachant que la section .data débute à l’adresse 0x1000.
.data # 0x1000
valeurs:
.int 0, 0, 0, 0, 0, 0, 0, 0
.text
movl $3, %eax
xorl %ebx, %ebx
movl $0x12345678, valeurs(%ebx, %eax, 2)

Modes d’adressage
Exercice 7:
Donnez la valeur des octets aux adresses 0x1002 et 0x1006 à la fin de l’exécution
de ce programme, sachant que la section .data débute à l’adresse 0x1000.
.data # 0x1000 3 2 1 0
valeurs:
0x1000 0x00 0x00 0x00 0x00
.int 0, 0, 0, 0, 0, 0, 0, 0
.text 0x1004 0x56 0x78 0x00 0x00
movl $3, %eax 0x1008 0x00 0xF8 0x12 0x34
xorl %ebx, %ebx
movl $0x12345678, valeurs(%ebx, %eax, 2)

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements

Branchements
Types de branchement
•Sans condition: jmp quelquepart
― quelquepart est un entier/adresse/étiquette
― quelquepart peut aussi être « *opérande »
⚫ jmp *%eax # eip  R[eax]
⚫ jmp *4(%eax) # eip  M32[4 + R[eax]]
•Conditions: j? quelquepart
― Où ? est le nom de la condition: c, nc, z, nz, o… (voir document sur Moodle)
― Conditions sur eflags ou sur %ecx
•Appel/retour de sous-routine:
― call fonction
― ret
Branchements
Exemples et exercices de conditions
Comparaison: cmp y, x
― affecte eflags selon l’opération x-y
Suivant une comparaison non signée: (above/below)

jb: jump if below, CF = 1
Suivant une comparaison signée: (above/below)

jl: jump if below, SF ≠ OF
Beaucoup de redondance… Voir document en ligne.

Branchements
Structure de contrôle conditionnelle
En C: En assembleur:
if( a ) if:
b; # code pour a
else
j? partie_else
c;
# code pour b
jmp fin_du_if
partie_else:
# code pour c
fin_du_if:

Branchements
Structure de contrôle itérative
do{ boucle:
b; # code de b
} while(a);
# code de a
j? boucle

Branchements
while( a ){ jmp test_au_debut

b; boucle:
}
# code de b
test_au_debut:
# code de a
j? boucle

Branchements
for(a; b; c) # code de a
d; jmp test_au_debut
boucle:
Équivaut à
# code de d
a;
# code de c
while(b) {
test_au_debut:
d;
c; # code de b
} j? boucle

Plan de la séance
Assembleur IA-32
Modes d'adressage
Branchements

Exemple
Exécution
Programme
.data $> ./a.out
txt: .ascii "Hello World!\n\0" Hello World!
.text
.globl main
main:
pushl $txt
call printf
addl $4, %esp
ret

Exemple
Programme
.data
txt: .ascii "Hello World!\n\0"
.text
Définit une chaine de caractère
.globl main
main:
pushl $txt
call printf
addl $4, %esp
ret

Exemple
Programme
.data
.text
.globl main
main:
pushl $txt
call printf Instructions pour un appel de fonction
addl $4, %esp (voir plus loin Appels de fonctions)
ret

Exemple
Programme
.data
.text
.globl main
main:
pushl $txt
call printf Fonction permettant d’afficher du texte à la console
addl $4, %esp
ret

Exemple
Programme
.data
.text
.globl main
main:
pushl $txt Paramètre de la fonction:
call printf Adresse de la chaine de caractères à afficher
addl $4, %esp
ret

Exemple
Programme
.data
.text
.globl main
main:
pushl $txt
call printf
addl $4, %esp Sert à dépiler 4 octets (voir Concept de pile)
ret Pour retirer le paramètre de la fonction de la pile

Transfert des données (petit ajout)
Instructions usuelles
mov source, destination # destination  source
xchg a, b # a  b : b  a
lea source, destination # destination  adresse de source
― « lea » pour « load effective address »
― Source doit être de type mémoire, destination de type registre 32-bits
― Donc:
lea dep(%r1,%r2,k), %rd # RTN: R[rd]  dep+R[r1]+R[r2]*k
― Ex:
lea (%ebx,%ecx), %eax # RTN: R[eax]  R[ebx] + R[ecx]

Transfert des données (petit ajout 2)
Instructions pour empiler et dépiler
push source # destination  source
pop dest # destination  source
pusha source # push tous les registres (utile pour sauvegarde de contexte)
popa dest # pop tous les registres en ordre inverse

Exercice 8
Que fait ce programme?
.data
.text
.globl main
main:
movl $3, %ebx
L1:
pushl $txt
call printf
addl $4, %esp
subl $1, %ebx
jnz L1
ret

Exercice 8
Que fait ce programme? Exécution
.data
.text
$> ./a.out
.globl main Hello World!
Hello World!
main: Hello World!
movl $3, %ebx
L1:
pushl $txt
call printf
addl $4, %esp
subl $1, %ebx
jnz L1
ret

Exercice 9
Que fait ce programme?
.data
IT : .int 3
.text
.globl main
main:
movl IT, %ebx
L1:
pushl $txt
call printf
addl $4, %esp
subl $1, %ebx
jnz L1
ret

Exercice 9
Que fait ce programme? Exécution
.data
IT : .int 3
$> ./a.out
.text Hello World!
.globl main Hello World!
main: Hello World!
movl IT, %ebx
L1:
pushl $txt
call printf
addl $4, %esp
subl $1, %ebx
jnz L1
ret

Exercice 10
Considérez ce programme. Quel est le contenu de la mémoire à l’adresse F à la fin du programme?
.data
IT: .int 4 eax
F: .int 0, 1, 0, 0, 0, 0
.text
.globl main
main:
movl IT, %ecx ecx
movl $F, %edx
L1: IT 0x4000 4
movl (%edx), %eax
edx
F 0x4004 0
addl 4(%edx), %eax
movl %eax, 8(%edx) 0x4008 1
addl $4, %edx 0x400C 0
0x4010 0
subl $1, %ecx 0
jnz L1 0x4014
ret 0x4018 0

Exercice 10
Considérez ce programme. Quel est le contenu de la mémoire à l’adresse F à la fin du programme?
.data
IT: .int 4
F: .int 0, 1, 0, 0, 0, 0
.text Réponse:
.globl main
main:
movl IT, %ecx
F: .int 0, 1, 1, 2, 3, 5
movl $F, %edx
L1: IT 0x4000 4
movl (%edx), %eax F 0x4004 0
addl 4(%edx), %eax
movl %eax, 8(%edx) 0x4008 1
addl $4, %edx 0x400C 1
0x4010 2
subl $1, %ecx 3
jnz L1 0x4014
ret 0x4018 5

Branchements (petit ajout 3)
Instructions spéciales: loop, loopz, loopnz
N’affectent pas les flags
loop kekpart # ecx  exc – 1; if( ecx ≠ 0) eip  kekpart
loopz kekpart # ecx  exc – 1; if( ecx ≠ 0 ET ZF = 1 ) eip  kekpart
loopnz kekpart # ecx  exc – 1; if( ecx ≠ 0 ET ZF = 0 ) eip  kekpart

Exercice 11
Considérez ce programme. Récrivez-le avec l’instruction loop
.data
IT: .int 4
F: .int 0, 1, 0, 0, 0, 0
.text
.globl main
main:
movl IT, %ecx
movl $F, %edx
L1:
movl (%edx), %eax
addl 4(%edx), %eax
movl %eax, 8(%edx)
addl $4, %edx
subl $1, %ecx

jnz L1
ret

Exercice 11
Considérez ce programme. Récrivez-le avec l’instruction loop
.data
IT: .int 4
F: .int 0, 1, 0, 0, 0, 0
.text
.globl main
main:
movl IT, %ecx
movl $F, %edx
L1:
movl (%edx), %eax
addl 4(%edx), %eax
movl %eax, 8(%edx)
addl $4, %edx
subl $1, %ecx

loop L1 jnz L1
ret

Exemples et exercices .data
A: .int 81
B: .int 15
C: .int 0
Exercice 12 .text
.globl main
À faire à la maison. main:
movl A, %eax
Considérez le programme ci-contre. Compilez-le movl B, %edx
et tentez de comprendre ce qu’il fait. jmp Test
L1:
Que contiennent les registres %eax et %edx à la sub %edx, %eax
fin du programme? Test:
cmp %edx, %eax
Que contient l’emplacement mémoire étiqueté C
jae L1
à la fin du programme?
À quoi correspond cette valeur? movl %eax, C
movl $0, %eax

ret

Cours 03

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours 03

Transféré par

Droits d'auteur :

Formats disponibles

Assembleur

Introduction à l’assembleur x86

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 2

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 3

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 4

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 5

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 6

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 7

• Pareil pour les quatre premiers registres 31 16 15 8 7 0

o eax, ax, ah, al

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 8

• Indicateurs (eflags) - NT IOPL OF DF IF TF SF ZF - AF - PF - CF

― CF: carry; retenue/emprunt; débordement non signé

― AF: auxiliary carry; pour le BCD

― ZF: zero; vrai si le résultat est zéro

― SF: sign; vrai si le résultat est négatif

― DF: direction (DF = faux → inc; DF = vrai → dec)

― OF: overflow; débordement signé

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 9

Registres usage général Registres état et contrôle

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 10

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 11

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 12

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 13

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 14

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 15

# on est dans le segment des instructions)

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 16

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 17

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 18

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 19

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 20

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 21

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 22

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 23

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 24

.float 12.54 # M32[1015] = 12.54 en IEEE-754 sur 32-bits, soit 0x4148a3d7

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 25

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 26

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 27

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 28

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 29

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 30

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 31

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 32

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 33

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 34

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 35

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 36

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 37

addw $4, 1234 # M16[1234]  M16[1234] + 4

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 38

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 39

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 40

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 41

Suivant une comparaison non signée: (above/below)

Suivant une comparaison signée: (above/below)

Beaucoup de redondance… Voir document en ligne.

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 43

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 44

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 45

while( a ){ jmp test_au_debut

Mise à jour: 2022/01/27 INF1600: Architecture des micro-ordinateurs 46