[Débutante] Masquage et décalages

**bolo** · 13/07/2004, 16h38

Bonjour,

voici un algo

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Programme Générateur Pseudo Aléatoire
Début :
     BH <- 12h
boucle:
    AL <- BH
    Si (AL = 0) alors AL <- 0FFh Fin Si (cmp et Jxyz, le h signifie hexadécimal en assembleur)
    AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
    BL <-0
   CX <- 8
   Répéter
     Décaler AL à droite de 1 rang (utiliser l'instruction SHR de l'assembleur)
     Si Carry = 1 alors BL <- BL + 1 Fin Si
     CX <- CX-1
   Jusqu'à CX = 0 (utiliser l'instruction LOOP de l'assembleur)
   Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
   rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)
Aller à l'étiquette boucle (instruction jmp de l'assembleur)
Fin

sur cette ligne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)

on fait un masque d'apres l'explication de ce programe

On garde avec un masque (0B8h) les bits 7,5,4,3 du nombre précédent.

qqn peut m'expliquer pourquoi ce sonts les bits 7.5.4.3 qui sont gardée car moi je trouve pour 0B8 => 10111000

merci

**le mage tophinus** · 13/07/2004, 16h52

salut,

tout d'abord en assembleur les bits sont numérotés de 0 à x mais il faut lire de droite vers la gauche. Je m'explique : pour ton 10111000b, le bit 7 vaut 1, le bit 6 vaut 0, le bit 5 = 1, bit 4= 1, bit 3 = 1, bit 2 = 0, bit 1 = 0 , bit 0 = 0

maintenant reste l'opérateur AND : il compare bit à bit deux nombres pour en créer un troisième avec l'algo suivant (Soit n1 et n2 les deux nombres et nR le résultat) :
pour le bit x de nR : si le bit x de n1 vaut 1 ET si le bit x de n2 vaut 1 alors le bit x de nR vaut 1, dans les trois autres cas, le bit x de nR prend la valeur 0

Donc en faisant un AND AL,0B8h ou un AND AL,10111000b ; tu forces à garder uniquement les bits 7,5,4 et 3. Si tu as du mal à comprendre encore, essaye de le dérouler à la main sur du papier et si tu comprends toujours pas reposte et j'essayerais d'être plus clair

Bienvenu dans le mode fou de l'assembleur

**Smortex** · 13/07/2004, 16h56

Salut !

Hihi ... tu lis a l'envert je pense

En decimal, 1234 c'est :

4 pour les unites
3 pour les dizaines
2 pour les centaines
1 pour les milliers

Si tu prends un demi-octet, 4 bits, celui de poind fort est a gauche et celui de poids faible a droite... Si on les "ponderise" :
3210

donc si tu as 8 en base 10, ca te donne 1000 en base 2.

Le bit 0 vaut 0
Le bit 1 vaut 0
Le bit 2 vaut 0
Le bit 3 vaut 1

Dans ton cas, tu as :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Ce sont bien les bits 7, 5, 4 et 3 qui sont conserves

Bon developpement !

-- edit --
Bon, j'ai ete un peu lent sur cette action moa ... je laisse des fois que ca complete

**bolo** · 13/07/2004, 17h00

tout d'abord en assembleur les bits sont numérotés de 0 à x mais il faut lire de droite vers la gauche. Je m'explique : pour ton 10111000b, le bit 7 vaut 1, le bit 6 vaut 0, le bit 5 = 1, bit 4= 1, bit 3 = 1, bit 2 = 0, bit 1 = 0 , bit 0 = 0

d'apres ce que je comprends je dois lire de droite a gauche mais moi pour cette valeur
10111000b
pour le bit numéro 7 j'ai 0 , peut etre voulais tu dire de gauche a droite , pourquoi as tu mis un b a la fin ?

Donc en faisant un AND AL,0B8h ou un AND AL,10111000b ; tu forces à garder uniquement les bits 7,5,4 et 3. Si tu as du mal à comprendre encore, essaye de le dérouler à la main sur du papier et si tu comprends toujours pas reposte et j'essayerais d'être plus clair

Dc si j'ai bien compris je ne garde que les bits 7.4.5 et 3 et ca me donne un nouveau nombre

j'ai une autre question
Le prof nous dit que

Le résultat de Nombre ET 0B8h vaut 10h

donc la il fait masque de la valeur 12h and 0B8 soit
000010010
101110000
-------------
000010000 soit 10 h

c'est ca ?

j'ai un autre question a ce niveau

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Décaler AL à droite de 1 rang (utiliser l'instruction SHR de l'assembleur)

un décalage à droite permet de faire une dévision ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Si Carry = 1 alors BL <- BL + 1 Fin Si

cette ligne permet de faire une comparaison , si la valeur est égal a 1 alors on ajoute un au registre Bl c'est ca ?

**Arnaudv6** · 13/07/2004, 17h27

"b", c'est simplement pour "binaire"
"h" serait l'equivalent pour préciser au compilo "hexadecimal"
et "d" pour decimal, mais suivant les compilos, pas besoin de le préciser
(nasm par exemple), parce qu'il sait que les humains sont naturellement decimaux....

**bolo** · 13/07/2004, 17h28

et en fait on compe de 0 a 10 et 1 a 10 c'est pour que je comprenais pas

En passant dans cette partie

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
   rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)

je comprends pas ce qu'il fait

**TangiX** · 13/07/2004, 21h16

lut'

le carry est un bit de flag dans lequel sont placé les depassements.
l'instruction SHR va decaler tout les bits de BL vers la droite et donc le bit 0 qui etait le plus a droite (donc le bit 0) est placer dans le flag carry.

RCR BH,1 fera ceci --> CF > xxxxxxxx > CF
CF c pour carry flag, les 8 x representes les bits de BH

**bolo** · 13/07/2004, 21h33

d'accord mais ca sert a quoi cette instruction
lorsque l'on fait un déclage vers la droite ca permet de faire une devision ?

**Neitsa** · 13/07/2004, 21h45

Bonjour,

Oui bolo, le décalage à droite est une manière rapide de diviser par une puissance de 2.

En décalant d'un bit à chaque fois:
1er décalage: division par 2^1
2eme décalage: division par 2^2
3eme décalage : division par 2^3
etc...
A condition que le chiffre soit pair.

S'il est impair, c'est comme si on retranchait d'abord 1 puis que l'on divisait par une puissance de 2.

ex:

0x29 SHR 2 = 0x0A

soit (décimal)=> (40 -1) /4 = 10

Neitsa.

**bolo** · 13/07/2004, 21h48

merci pour la confirmation donc ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Décaler AL à droite de 1 rang (utiliser l'instruction SHR de l'assembleur)
     Si Carry = 1 alors BL <- BL + 1 Fin Si
     CX <- CX-1
   Jusqu'à CX = 0 (utiliser l'instruction LOOP de l'assembleur)
   Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
   rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)
Aller à l'étiquette boucle (instruction jmp de l'assembleur)

dc a chaque itération on devise la valeur du registre tant que CX n'est pas vide?

**Neitsa** · 13/07/2004, 22h16

dc a chaque itération on devise la valeur du registre tant que CX n'est pas vide?

oui c'est ca, avec:

CX <- 8 et LOOP

on procéde 8 fois au SHR (donc incidemment une division par 2^8)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
MOV CX,8
@@BoucleCarry:
SHR AL,1
JNC @@NoCarry
INC BL
@@NoCarry:
LOOP @@BoucleCarry
SHR BL,1
RCR BH,1
JMP Boucle

Qque chose comme ca pour la fin...

**bolo** · 14/07/2004, 17h01

je suis en train de convertir l'algo en assambleur
alors ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 boucle:
    AL <- BH
    Si (AL = 0) alors AL <- 0FFh Fin Si (cmp et Jxyz, le h signifie hexadécimal en assembleur)
    AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
    BL <-0
   CX <- 8
   Répéter
     Décaler AL à droite de 1 rang (utiliser l'instruction SHR de l'assembleur)
     Si Carry = 1 alors BL <- BL + 1 Fin Si
     CX <- CX-1
   Jusqu'à CX = 0 (utiliser l'instruction LOOP de l'assembleur)
   Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
   rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)
Aller à l'étiquette boucle (instruction jmp de l'assembleur)
Fin

La dernière partie j'ai surement fais un peu n'importe quoi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
.model small
.stack 100h
 
.code
			mov bh , 12h
 debut :
      mov al ; bh
 suite:
      cmp al , 0 ; si al = 0
			JNZ sinon ; si la condition n'est fause
 alors:
 mov al , 0FFh
			JMP FinSi   ; la condifition est terminée on bascule vers end if
 sinon:
     and al , 0B8h
     mov bh , 0
		 mov cx , 8 ; compteur de la boucle
 FinSi:  
 boucle :
      mov al , bh
      shr al , 1
      dec cx
			JB suite2
 suite2
        loop boucle
	      shr bl ,0
	      rcr bl ,1
 FinSuite2:
 mov ah,4Ch
 int 21h
end

**le mage tophinus** · 15/07/2004, 13h17

waouh, y'a encore un peu de boulot ...

1)

AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
BL <-0
CX <- 8

tu le codes par :

and al , 0B8h
mov bh , 0
mov cx , 8 ; compteur de la boucle

faut faire un mov bl,0 !!!

2)

Répéter
Décaler AL à droite de 1 rang (utiliser l'instruction SHR de l'assembleur)
Si Carry = 1 alors BL <- BL + 1 Fin Si
CX <- CX-1
Jusqu'à CX = 0 (utiliser l'instruction LOOP de l'assembleur)

tu fais :

boucle :
mov al , bh
shr al , 1
dec cx
JB suite2
suite2
loop boucle

premièrement, je cromprends pas pourquoi tu fais un "mov al,bh". Deuzio, avec un loop, tu n'as pas besoin de faire un dec cx car il est fait automatiquement. J'aurais plutôt fait ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
boucle:
      shr al,1
      jnc pas_de_retenue   ; saute vers "pas_de_retenue" si carry=0
      inc bl
pas_de_retenue:
      loop boucle

3)

Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)

là, il est vrai que c'est pas super évident. Pour mettre le bit 0 de BL dans le carry, je pense (pour s'assurer du résultat) qu'il faut d'abord mettre le bit 0 de BL dans le bit 7 de BL puis refaire un décalage de 1 bit pour être sûr que le carry ne contienne que la retenue due au décalage du bit 0. ça donnerait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
shr bl,7
shr bl,1
rcr bl,1

voilà en gros, ce que j'ai remarqué mais j'ai peut-être pas tout vu. N'hésites pas à poser des questions au cas où

**bolo** · 15/07/2004, 15h00

Salut,

en fait je l'avais refaits le voici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
.model small
.stack 100h
 
.code
			mov bh , 12h
 debut :
      mov al , bh
      cmp al , 0 ; 
			JNZ suite1 ; si la condition n'est fause
			mov al , 0FFh
 suite1:
     and al , 0B8h
     mov bh , 0
		 mov cx , 8 ; compteur de la boucle
 boucle :
     shr al , 1
    inc  bl  ; on ajoute 1 a bl
    JNC suite2
 suite2
        loop boucle
	      shr bl ,0
	      rcr bl ,1
 mov ah,4Ch
 int 21h
end

Carry <- Bit 0 de BL (utiliser l'instruction SHR de l'assembleur)
rotation de BH à droite avec le carry de 1 rang (utiliser l'instruction RCR)

là, il est vrai que c'est pas super évident. Pour mettre le bit 0 de BL dans le carry,

De plus il y a un truc que je ne capte pas c'est comment on peut mettre un bit dans un Flag c'est possible de faire ceci ?

je pense (pour s'assurer du résultat) qu'il faut d'abord mettre le bit 0 de BL dans le bit 7 de BL puis refaire un décalage de 1 bit pour être sûr que le carry ne contienne que la retenue due au décalage du bit 0. ça donnerait :

la je n'ai pas tt capté

J'ai la correction , j'ai essaye de le faire sans regarder , le prof a fait ainsi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
.model small
.stack 100h
.code
     mov bh,12h
debut:
     mov al,bh
     cmp al,0
     jne suite
     mov al,0FFh
suite:
     and al,0B8h
     mov bl,0
     mov cx,8
boucle:
     shr al,1
     jnc suite2
     add bl,1
suite2:
     loop boucle
     shr bl,1
     rcr bh,1
     jmp debut
     mov ah,4ch
     int 21h
end

**le mage tophinus** · 15/07/2004, 15h49

la je n'ai pas tt capté

oups, autant pour moi, j'ai fait une bourde

J'ai tellement l'habitude de travailler avec SHL que j'ai pas fait le contact que c'était SHR. En fait, SHR décale les bits vers la droite (et non vers la gauche

) donc quand tu fais SHR bl,1; le bit 1 devient le bit 0, le dit 2 devient le bit 1 , ..... je pense que ça tu l'as compris. Mais alors que devient le bit 0 ??? Et bien le bit 0 passe dans le CARRY car quand tu fais shr bl,1 c'est comme si tu faisais une division entière par 2 donc tu connais pas le reste et donc le CARRY se met à 1 (CARRY=retenue) pour dire qu'il existe un reste à ton opération mais attention il n'est pas sauvegardé quelque part, c'est juste pour prévenir de l'opération. Dans le sens inverse, s'il n'y a pas de reste (ou retenue), le Carry est mis à 0. Comme la retenue est basée sur le bit 0, cette instruction permet donc de mettre le bit 0 dans le carry (c'est une astuce en fait

)

Petite paranthèse en plus mais qui n'a pas grand chose à voir avec l'algo, le bit 0 sert aussi à déterminer si ton nombre est pair ou impair, c'est bon à savoir ça aussi

**bolo** · 15/07/2004, 16h07

mon code est il bon ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
.model small
.stack 100h
 
.code
         mov bh , 12h
 debut :
      mov al , bh
      cmp al , 0 ;
         JNZ suite1 ; si la condition n'est fause
         mov al , 0FFh
 suite1:
     and al , 0B8h
     mov bh , 0
       mov cx , 8 ; compteur de la boucle
 boucle :
     shr al , 1
    inc  bl  ; on ajoute 1 a bl
    JNC suite2
 suite2
        loop boucle
         shr bl ,0
         rcr bl ,1
 mov ah,4Ch
 int 21h
end

le bit 0 permet de déterminé si le chifre est positif ou non ?

**le mage tophinus** · 15/07/2004, 16h35

1)

Si Carry = 1 alors BL <- BL + 1 Fin Si

vérifie bien, tu fais une erreur en codant ça !

2)

suite1:
and al , 0B8h
mov bh , 0
mov cx , 8 ; compteur de la boucle

On te demande de faire :

AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
BL <-0
CX <- 8

Fais attention aux registres que tu utilises !!!

loop boucle
shr bl ,0
rcr bl ,1

au niveau de l'instruction SHR tu fais une erreur. SHR BL,x permet de faire un décalage de x bits vers la droite, en gros tu divise BL par 2^x (2 à la puissance x) et 2^0 ça donne 1 donc SHR BL,0 ne change rien du tout !!!

Poses-toi un peu plus sur ton problème tranquillement, tu vas beaucoup trop vite, c'est une grosse erreur en assembleur

**bolo** · 15/07/2004, 16h56

Si Carry = 1 alors BL <- BL + 1 Fin Si

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
JC suite1 ; si la condition est vrai carry = 1
mov al , 0FFh
suite1:
INC BL

AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
BL <-0
CX <- 8

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
and al , 0B8h
mov bL , 0
mov cx , 8 ; compteur de la boucle

au niveau de l'instruction SHR tu fais une erreur. SHR BL,x permet de faire un décalage de x bits vers la droite, en gros tu divise BL par 2^x (2 à la puissance x) et 2^0 ça donne 1 donc SHR BL,0 ne change rien du tout !!!

dc en fait je dois faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

shr bl ,1

en fait moi je n'arrive pa bien a suivre a cause de manière comment sont struturée l'algo

boucle:
AL <- BH
Si (AL = 0) alors AL <- 0FFh Fin Si (cmp et Jxyz, le h signifie hexadécimal en assembleur)
AL <- AL ET 0B8h (utiliser l'instruction AND de l'assembleur)
BL <-0
CX <- 8

Par exemple cette partie est défine dans la boucle ou hors de la boucle ?

**le mage tophinus** · 15/07/2004, 17h07

Si Carry = 1 alors BL <- BL + 1 Fin Si

Code:
JC suite1 ; si la condition est vrai carry = 1
mov al , 0FFh
suite1:
INC BL

Que vient faire "mov al,0FFh" ici ??? tu n'as toujours pas trouver l'erreur !!!

en fait moi je n'arrive pa bien a suivre a cause de manière comment sont struturée l'algo

Je te rassure, c'est pareil pour moi. En plus, la difficulté de passer ça à travers le net, ça donne pas toujours ce qu'il faut. M'enfin, le net permet quand-même de résoudre des problèmes

Maintenant que tu es quasi à côté de la solution, je te suggère de regarder la correction de ton prof vu que tu l'as. Et si tu as encore des questions après avoir fait la comparaison des deux codes, tu sais ce qu'il te reste à faire

**bolo** · 15/07/2004, 17h13

Dans la correction du prof

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
debut:
mov al,bh
cmp al,0
jne suite
mov al,0FFh
suite:

si j'ai bien compris si al n'est pas egal a 0 on va l'étiquette suite jusque la je comprends mais dans ton message précédent tu me demandes

Que vient faire "mov al,0FFh" ici ??? tu n'as toujours pas trouver l'erreur !!

il a fait le meme chose , non ?

[Débutante] Masquage et décalages

Assembleur

Discussions similaires

Partager

Partager