Scribd
Importer
48 vues12 pages

Série 2 Correction+

Transféré par

نور القلوب
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd
48 vues12 pages

Série 2 Correction+

Transféré par

نور القلوب
Copyright
© © All Rights Reserved
Nous prenons très au sérieux les droits relatifs au contenu. Si vous pensez qu’il s’agit de votre contenu, signalez une atteinte au droit d’auteur ici.
Formats disponibles
Téléchargez aux formats PDF, TXT ou lisez en ligne sur Scribd

Université Mohammed Premier Année Universitaire : 2022-2023

Faculté des Sciences - Oujda Module : Architecture des ordinateurs


Département d’informatique Filière : SMI
Pr. Khadija LAAROUSSI Semestre 4

Correction de la série N°2


Séance 4
Exercice 1
1)
- On a un mot (word) est représenté sur 2 octets, ce qui correspond aux 2 adresses mémoires
0x80120002 et 0x80120003.
- Les octets qui se trouvent dans les deux adresses mémoires sont 0x00 et 0x01
respectivement.
- La valeur en hexadécimal est 0x0100 (en appliquant le principe de mettre l’octet de poids
fort à l’adresse haute).
- Son équivalent en binaire est : 0000 0001 0000 0000 ⟹ 28 en décimal.
- D’où, la valeur en décimal est 256.
2)
- On a un mot double (double word) est représenté sur 4 octets, ce qui correspond aux 4
adresses mémoires suivantes 0x80120006, 0x80120007, 0x80120008 et 0x80120009.
- Les octets qui se trouvent dans les 4 adresses mémoires sont 0x40, 0x43, 0x01 et 0x00
respectivement.
- La valeur en hexadécimal est 0x00014340 (en appliquant le principe de mettre l’octet de
poids fort à l’adresse haute).
- Son équivalent en binaire est : 0000 0000 0000 0001 0100 0011 0100 0000 ⟹ 26 + 28 + 29
+ 214 + 216 = 82752 en décimal.
- D’où, la valeur en décimal est 82752.
3)
- On a une valeur virgule flottante simple précision est représentée sur 4 octets, ce qui
correspond aux 4 adresses mémoires suivantes 0x80120004, 0x80120005, 0x80120006 et
0x80120007.
- Les octets qui se trouvent dans les 4 adresses mémoires sont 0x00, 0x00, 0x40 et 0x43
respectivement.
- La valeur en hexadécimal est 0x43400000.
- Son équivalent en binaire est : 0100 0011 0100 0000 0000 0000 0000 0000.
- Représentation flottante simple précision :
0 10000110 10000000000000000000000
- Le bit de signe est 0. La valeur est donc positive.
- L’exposant est 100001102 soit 13410. Il faudra donc trouver l’exposant scientifique
E = e + Eb ⟹ e = E – Eb ⟹ e = 134 – 127 ⟹ e = 7
- La partie fractionnaire est 1.100000000000000000000002, soit 1.510. (1 × 2-1)

1/12
- La valeur est donc 1.5 × 27 soit 192.0.
Exercice 2
Instruction Type d’adressage
mov CX,10 Immédiat
mov DI,0 Immédiat
mov AX,0 Immédiat
add AX,[DI+200h] Indexé avec déplacement
add AX,[BX+100h] Basé avec déplacement
mov [300h],AX Direct

Exercice 3
On suppose les données suivantes : BX=637Eh, SI=2A9Bh et Déplacement=0F7h.

Mode d’adressage Calcul de l’adresse Adresse effective


Adressage basé par BX [BX] 637Eh
Adressage basé par BX avec [BX + déplacement] 637Eh + 00F7h = 6475h
déplacement sur 16 bits
Adressage immédiat Aucune adresse Aucune adresse
Adressage basé et indexé avec [BX + SI + déplacement] 637Eh + 2A9Bh + 00F7h
déplacement sur 16 bits = 8F10h

Séance 5
Exercice 1
INCLUDE irvine32.inc
.data?
a DWORD ?
b DWORD ?
.data
msg1 BYTE "Saisir un entier :",0
msg2 BYTE "La soustraction est:",0
.code
main PROC
mov edx,OFFSET msg1
call writestring
call readint
mov a,eax
mov edx,OFFSET msg1
call writestring
call readint
mov b,eax

2/12
mov eax,a
mov ebx,b
sub eax,ebx
mov edx,OFFSET msg2
call writestring
call writeint
main ENDP
END main

➢ Un exemple d'affichage obtenu après l’exécution du code :

Exercice 2
INCLUDE irvine32.inc
.data?
a DWORD ?
b DWORD ?
.data
msg1 BYTE "Saisir un entier :",0
msg2 BYTE "La somme est:",0
msg3 BYTE "La soustraction est:",0
msg4 BYTE "La multiplication est:",0
msg5 BYTE "Le quotient est:",0
msg6 BYTE "Le reste est:",0

.code
main PROC
mov edx,OFFSET msg1
call writestring
call readint
mov a,eax
mov edx,OFFSET msg1
call writestring
call readint
mov b,eax

; Addition
add eax,a
mov edx,OFFSET msg2
call writestring
call writeint

3/12
call crlf
; Soustraction
mov eax,a
mov ebx,b
sub eax,ebx
mov edx,OFFSET msg3
call writestring
call writeint
call crlf

; Multiplication
mov eax,a
mul ebx
mov edx,OFFSET msg4
call writestring
call writeint
call crlf

; Division
mov eax,a
mov ebx,b
mov edx,0
div ebx
mov ecx, edx
mov edx,OFFSET msg5
call writestring
call writeint
call crlf
mov eax,ecx ;
mov edx,OFFSET msg6
call writestring
call writeint
call crlf
main ENDP
END main

➢ Un exemple d'affichage obtenu après l’exécution du code :

4/12
Exercice 3
1)
OR DH,02h ; (0000 0010b) pour forcer le bit N°1 à 1
AND DH, F7h; (1111 0111b) pour forcer le bit N°3 à 0

Séance 6

Exercice 1
➢ Solution avec « jg » :
Include irvine32.inc
.data?
a DWORD ?
b DWORD ?
.data
msg1 BYTE "Saisir un entier :",0
msg2 BYTE "Maximum est :",0
.code
main PROC
mov edx,OFFSET msg1
call writestring
call readint
mov a, eax;
call writestring
call readint
mov edx,OFFSET msg2
call writestring
cmp a, eax
jg Superieur
call writeint
jmp Stop

Superieur:
mov eax,a
call writeint
exit
Stop:
main endp
end main

5/12
➢ Solution avec « jl » :
Include irvine32.inc
.data?
a DWORD ?
b DWORD ?
.data
msg1 BYTE "Saisir un entier :",0
msg2 BYTE "Maximum est :",0
.code
main proc
mov edx,OFFSET msg1
call writestring
call readint
mov a, eax;
mov edx,OFFSET msg1
call writestring
call readint
cmp a, eax
jl Inferieur
mov eax, a
Inferieur:
mov edx,OFFSET msg2
call writestring
call writeint
exit
main endp
end main

➢ Un exemple d'affichage obtenu après l’exécution du code :

Exercice 2
Include Irvine32.inc
.data
msg1 byte "Saisir un entier: ",0
msg2 byte "Resultat est positif",0
msg3 byte "Resultat est nul",0
msg4 byte "Resultat est negatif",0
.code
main proc
mov edx, offset msg1

6/12
call writestring
call readint
mov ebx,eax
mov edx, offset msg1
call writestring
call readint
sub ebx,eax
jz Nul
js Negatif
mov edx,offset msg2
call writestring
JMP Fin
Nul:
mov edx,offset msg3
call writestring
JMP Fin
Negatif:
mov edx,offset msg4
call writestring
Fin:
main endp
end main

➢ Un exemple d'affichage obtenu après l’exécution du code :

Exercice 3
1) if (ax==1)
bx=10;
else {
bx=0;
cx=10;
}

7/12
CMP AX,1
JE Egal
mov BX,0
mov CX,10
JMP Fin
Egal:
mov BX, 10
Fin:
exit

➢ Le programme assembleur :

Include irvine32.inc
.data
msg1 byte "Saisir un entier:",0
msg2 byte "La valeur de ebx est:",0
msg3 byte "La valeur de ecx est:",0
.code
main proc
mov edx,offset msg1
call writestring
call readint
CMP eax,1
JE Egal
mov ebx,0
mov ecx,10
mov eax, ebx
mov edx,offset msg2
call writestring
call writeint
call crlf
mov eax, ecx
mov edx,offset msg3
call writestring
call writeint
JMP Fin

Egal:
mov ebx, 10
mov eax, ebx
mov edx,offset msg2
call writestring
call writeint

8/12
Fin:
exit
main endp
end main

➢ Un exemple d'affichage obtenu après l’exécution du code :

2) if ((ax>bx) && (cx<=dx)) {


ax = ax - bx;
cx = cx+dx;
}
➢ Pour des nombres signés :
CMP AX, BX
JG Etiq1
JMP Fin
Etiq1 :
CMP CX, DX
JLE Etiq2
JMP Fin
Etiq2 :
SUB AX, BX
ADD CX, DX
Fin:

➢ Le programme assembleur :
Include irvine32.inc
.data?
a dword ?
b dword ?
cc dword ?
d dword ?
.data
msg1 byte "Saisir un entier:",0
msg2 byte "La valeur de eax est:",0
msg3 byte "La valeur de ecx est:",0

9/12
msg4 byte "La condition n est pas verifiee!",0
.code
main proc
mov edx,offset msg1
call writestring
call readint
mov a, eax
mov edx,offset msg1
call writestring
call readint
mov b, eax
mov edx,offset msg1
call writestring
call readint
mov cc, eax
mov edx,offset msg1
call writestring
call readint
mov d, eax
mov eax,a
mov ebx,b
mov ecx,cc
mov edx, d
CMP eax,ebx
JG Etiq1 ; si la 1ère condition est vérifiée on passe à la 2ème condition
JMP Fin
Etiq1:; on doit évaluer la 2ème condition
CMP ecx,edx
jle Etiq2 ; içi les deux conditions sont vérifiées
JMP Fin
Etiq2:
sub eax,ebx
mov edx,offset msg2
call writestring
call writeint
call crlf

mov edx,d
add ecx,edx
mov eax,ecx
mov edx,offset msg3
call writestring
call writeint
exit

10/12
Fin:
mov edx,offset msg4
call writestring
main endp
end main

➢ Un exemple d'affichage obtenu après l’exécution du code :

➢ Solution plus optimisée :


CMP AX, BX
JLE Fin
CMP CX, DX
JG Fin
SUB AX,BX
ADD CX,DX
Fin:

Include irvine32.inc
.data?
a dword ?
b dword ?
cc dword ?
d dword ?

.data
msg1 byte "Saisir un entier:",0
msg2 byte "La valeur de eax est:",0
msg3 byte "La valeur de ecx est:",0
msg4 byte "La condition n est pas verifiee!",0
.code
main proc
mov edx,offset msg1
call writestring

11/12
call readint
mov a, eax
mov edx,offset msg1
call writestring
call readint
mov b, eax
mov edx,offset msg1
call writestring
call readint
mov cc, eax
mov edx,offset msg1
call writestring
call readint
mov d, eax
mov eax,a
mov ebx,b
mov ecx,cc
mov edx, d
CMP eax,ebx
JLE Fin
CMP ecx,edx
jg Fin
sub eax,ebx
mov edx,offset msg2
call writestring
call writeint
call crlf
mov edx,d
add ecx,edx
mov eax,ecx
mov edx,offset msg3
call writestring
call writeint
exit
Fin:
mov edx,offset msg4
call writestring
main endp
end main

12/12

Vous aimerez peut-être aussi