@Pierre Marchand, 200259 IFT-17584 Semaine 04 Programmation système.

Présentation au sujet: "@Pierre Marchand, 200259 IFT-17584 Semaine 04 Programmation système."— Transcription de la présentation:

1 @Pierre Marchand, 200259 IFT-17584 Semaine 04 Programmation système

2 @Pierre Marchand, 200260 Plan de la rencontre Retour sur la semaine précédente Comparaison Branchements Structure de contrôle Chaînes de caractères et tableaux Instructions logiques Instructions arithmétiques

3 @Pierre Marchand, 200261 La semaine précédente Les modes d’adressages La gestion de la piles Le passage des arguments

4 @Pierre Marchand, 200262 Comparaison Lors d'une comparaison, par exemple cmp a,b, le processeur effectue la soustraction a – b et positionne les indicateurs selon le résultat de l'opération. Les indicateurs qui nous intéressent ici sont :  ZF = zero flag = 1 si le résultat est nul, sinon ZF = 0,  CF = carry flag = 1 si une retenue est générée, sinon CF = 0,  SF = sign flag = 1 si le résultat est négatif, sinon SF = 0,  OF = overflow flag = 1 s'il y a débordement de capacité, sinon OF = 0 On rappelle qu’un débordement de capacité a lieu si, lors d’une opération sur des opérandes de même signe, le résultat est de signe différent.

5 @Pierre Marchand, 200263 Effets des addition sur les flags Addition CasExempleSFZFOFCF 1.P + P = P20 + 30 = 500000 2.P+ P = N *40 + 50 = 901010 3.P+ N = P70 + F0 = 6000 01 4.P+ N = N50 + 90 = E01000 5.N+ N = P *A0 + 90 = 300011 6.N+ N = NF0 + E0 = D01001

6 @Pierre Marchand, 200264 Effets des soustraction sur les flags Rappelons-nous que la comparaison est en fait une soustraction Cas ExempleSFZFOFCF 1.P - P = P40 - 20 = 200000 2.P - P = N20 - 40 = E01001 3. P - N = P50 - F0 = 600001 4.P - N = N *30 - 90 = A01011 5.N - P = P *B0 - 70 = 400010 6.N - P = NA0 - 10 = 901000 7.N - N = PC0 - A0 = 200000 8.N - N = NA0 - F0 = B01001

7 @Pierre Marchand, 200265 A > B (non signé) Exemple CasSFZFOFCF A > 0 et B > 050 - 10 = 40P - P = P0000 A 090 - 20 = 70N - P = P0010 A 090 - 10 = 80N - P = N1000 A < 0 et B < 090 - 80 = 10N - N = P0000 Contre exemple : A > 0 et B > 020 - 30 = F0P - P = N1001 A > 0 et B > 040 - 40 = 00P - P = P0100 A < 0 et B < 080 - 90 = F0N - N = N1001 A < 0 et B < 0A0 - A0 = 00N - N = P0100 C’est-à-dire : ZF = 0 et CF = 0.

8 @Pierre Marchand, 200266 comparaisons non signés On peut dériver de la sorte les conditions suivantes pour des quantités non signées:  a (above)ZF = 0 et CF = 0>  ae (above or equal)CF = 0>=  b (below) CF = 1<  be (below or equal)CF = 1 ou ZF = 1<=

9 @Pierre Marchand, 200267 A > B (signé) Exemple CasSFZFOFCF A > 0 et B > 0: 50 - 10 = 40P - P = P0000 A > 0 et B < 0: 50 - F0 = 60P - N = P0001 A > 0 et B < 0: 50 - 90 = C0P - N = N1011 A < 0 et B < 0: F0 - 90 = 60N - N = P0000 Contre exemple: A > 0 et B > 0: 20 - 30 = F0P - P = N0011 A > 0 et B > 0: 40 - 40 = 00P - P = P0100 A 0: 90 - 50 = 40N - P = P0011 A 0: F0 - 40 = B0N - P = N1000 A < 0 et B < 0: 90 - F0 = A0N - N = N1001 C’est-à-dire : ZF = 0 et SF = OF.

10 @Pierre Marchand, 200268 Comparaisons signés On peut de la même façon dériver les conditions suivantes pour les quantités signées :  g (greater) ZF = 0 et SF = OF  ge (greater or equal)SF = OF  l (less)SF  OF  le (less or equal)ZF = 1 ou SF  OF

11 @Pierre Marchand, 200269 Branchements inconditionnels call jmpjump ret, retn, retf, iretreturn (near, far), interrupt return

12 @Pierre Marchand, 200270 Branchements conditionnels simple jejump if equal: ZF = 1 jnejump if not equal:ZF = 0 jzjump if zero: ZF = 1 jnzjump if not zero:ZF = 0

13 @Pierre Marchand, 200271 Branchements conditionnels non signés jajump above (x > y non-signé )CF = 0 & ZF = 0 jnajump not above = jbe jaejump above or equal CF = 0 jnaejump not above or equal = jb jbjump below (x < y non-signé)CF = 1 jnbjump not below = jae jbejump below or equal CF = 1 | ZF = 1 jnbejump not below or equal = ja

14 @Pierre Marchand, 200272 Branchements conditionnels pures Sur les indicateurs eux mêmes jcjump if carry: CF = 1 jncjump if not carry: CF = 0 jojump if overflow: OF = 1 jnojump if not overflow: OF = 0 jpjump if parity: PF = 1 jnpjump if not parity: PF = 0 jpojump if parity odd: PF = 0 jsjump if sign: SF = 1 (negative) jnsjump if no sign: SF = 0

15 @Pierre Marchand, 200273 Branchements conditionnels signés jgjump greater (x > y signé)SF = OF & ZF = 0 jngjump not greaterSF != OF & ZF = 1 jgejump greater or equalSF = OF jngejump not greater or equal = jl jljump less (x < y signé)SF != OF jnljump not less = jge jlejump less or equalSF != OF jnlejump not less or equal = jg

16 @Pierre Marchand, 200274 Branchements sur compteur jcxzjump if cx = 0 jecxzjump if ecx = 0

17 @Pierre Marchand, 200275 Variables signés ou non signés Il faut bien prendre garde d'utiliser le bon branchement selon le type de données considéré. En C, les variables sont signées par défaut. Pour avoir des variables non signées, on utilise la déclaration unsigned. Exemples : unsigned char x;0 ≤ x ≤ 255 unsigned short y;0 ≤ y ≤ 65535 unsigned long z; 0 ≤ z ≤ 4294967295 char x;-128 ≤ x ≤ 127 short y;-32768 ≤ y ≤ 32767 long z;-2147483648 ≤ z ≤ 2147483647

18 @Pierre Marchand, 200276 Structure de contrôle if simple if complexe while for switch

19 @Pierre Marchand, 200277 if simple if ( a > b )if:cmpa,b {jngelse… }… elsejmpendif {else:…… }endif:… Démontré dans l’exemple 01 disponible sur le site

20 @Pierre Marchand, 200278 if complexe if ( ( a > b ) && ( c <= d ) ) {if:cmpa,b …jngendif …cmpc,d }jnleendif … endif: Démontré dans l’exemple 01

21 @Pierre Marchand, 200279 while while ( a > b ) {while:cmpa,b …jngendwhile… }… jmpwhile endwhile:… Démontré dans l’exemple 01

22 @Pierre Marchand, 200280 for for ( i = 1; i < 10; i ++ ) {for:movi, 1 …jmptest …next:…… }inci test:cmpi, 10 jlnext endfor:… Démontré dans l’exemple 01

23 @Pierre Marchand, 200281 Instructions de boucle LOOP/LOOPW/LOOPD Loop Boucle vers une étiquette. Décrémente ecx en mode 32 bits ou cx en mode 16 bits (sans affecter aucun indicateur). Si (e)cx est 0 après avoir été décrémenté, l’exécution continue à l’instruction suivante. On peut forcer un comptage sur cx avec loopw et sur ecx avec loopd. L’étiquette doit être à moins de -128 à + 127 octets de l’instruction loop. oszapc = oszapc loopétiquette8 Démontré dans l’exemple 01

24 @Pierre Marchand, 200282 Instructions de boucle avec condition LOOPcc/LOOPccW/LOOPccD Loop Conditionally Boucle vers une étiquette tant que la condition est remplie et que (e)cx n’est pas 0. Décrémente ecx en mode 32 bits ou cx en mode 16 bits (sans affecter aucun indicateur). Si (e)cx est 0 après avoir été décrémenté, l’exécution continue à l’instruction suivante. On peut forcer un comptage sur cx avec loopw et sur ecx avec loopd. L’étiquette doit être à moins de -128 à + 127 octets de l’instruc- tion loop. oszapc = oszapc loopeétiquette8 loopz(w)étiquette 8 loopne(d)étiquette 8 Démontré dans l’exemple 01

25 @Pierre Marchand, 200283 Remplacement des instructions de boucle On peut remplacer avantageusement loop par les instructions qu’elle remplace : dececx; ou dec cx0.5 jnzboucle~0.5 Idem pour loopcc :; pour simuler loopz …; comparaison ou test jnzfinBoucle dececx jnzboucle finBoucle : Dans ce dernier cas il y a une petite différence. Si on sort de la boucle parce que ecx est 0, alors ZF = 1, tandis qu’avec loopcc ZF=1 seulement si la condition testée est 0. Il faut donc modifier légèrement le code subséquent.

26 @Pierre Marchand, 200284 Chaînes de caractères Types de chaînes Chaîne C Toto‘T’, ‘o’, ‘t’, ‘o’, \0 Chaîne Pascal Toto\04, ‘T’, ‘o’, ‘t’, ‘o’

27 @Pierre Marchand, 200285 Chaînes et tableaux Intel appelle également « chaîne » des tableaux de short, de long et autres. Un tableau est défini comme suit en C : short Tableau[n];// Tableau de n short non initialisés short Tableau[ ] = { 0, 2, -3, 4, 20 };// Tableau de 5 shorts Pour accéder à un élément d’un tableau, il y a deux façons : x = Tableau[i]; ou, si short * p = Tableau; alors x = *(p + 2 * i);// * 2 parce que short = 2 octets

28 @Pierre Marchand, 200286 Adressage des chaînes et tableaux Pour accéder à un tableau en assembleur, on fait lea esi, Tableau; ou mov esi, offset Tableau Ensuite, on utilise l’adressage indexé : movebx, i movax, [esi+ebx*2] movx, ax

29 @Pierre Marchand, 200287 Comparaison des chaînes et tableaux CMPSBCompare String Byte CMPSWCompare String Word CMPSDCompare String DoubleWord Compare l’octet, le mot ou le double mot pointé par esi avec l’octet, le mot ou le double mot pointé par edi. Les pointeurs esi et edi sont avancés automatiquement de 1, 2, ou 4 selon qu’il s’agit d’un octet, d’un mot ou d’un double mot. Si l’indicateur de direction DF est 0, esi et edi sont incrémentés. S’il est 1, esi et edi sont décrémentés.

30 @Pierre Marchand, 200288 Répétition des instruction de chaîne Cette instruction est souvent précédée de l’instruction REP ou REPcc. REPNE (ou REPNZ) est utilisé pour trouver la première correspondance entre deux chaînes. REPE est utilisé pour trouver la première différence entre deux chaînes. Avant la comparaison, ecx doit contenir le nombre maximum d’éléments à comparer. oszapc =       cmpsbyte ptr [esi] cmpsb repnecmpsw Attention, le résultat est l’inverse de cmp cmp fait dest - source cmps fait source - dest

31 @Pierre Marchand, 200289 Instructions rep REPRepeat String Répète une instruction de chaîne le nombre de fois indiqué dans ecx. oszapc = oszapc reprépéter tant que ecx ≠ 0 repe, repzrépéter tant que source = destination et ecx ≠ 0 repne, repnzrépéter tant que source ≠ destination et ecx ≠ 0

32 @Pierre Marchand, 200290 Autres instructions de chaînes SCAS/SCASB/SCASW/SCASDScan String Flags Dans le cas de SCAS, un opérande doit être fourni pour indiquer la taille des éléments à traiter. À la fin de l’instruction, edi pointe vers l’élément suivant. Si ecx = 0, edi pointe vers l’élément qui suit la dernière comparaison. L’indicateur ZF est affecté selon le résultat de la dernière comparaison et non selon la valeur de ecx. oszapc = ± ± ± ± ± ± scasword ptr [edi|4 repnescasb4 repescasw4

33 @Pierre Marchand, 200291 Charger une chaîne ou un tableaux LODS/LODSB/LODSW/LODSDLoad Acc. from String Charge l’accumulateur avec un élément d’une chaîne en mémoire. esi doit pointer vers l’élément source, même si un opérande est fourni. Pour chaque élément chargé, esi est ajusté selon la taille de l’opérande et l’indicateur de direction DF. esi est incrémenté si DF = 0 et décrémenté si DF = 1. oszapc = oszapc lodsword ptr [esi] lodsb lodsw lodsd Cette instruction ne peut pas être utilisée avec rep.

34 @Pierre Marchand, 200292 Écrire une chaînes en mémoire STOS/STOSB/STOSW/STOSDStore String Data Copie la valeur de AL, AX ou EAX dans un emplacement mémoire dont l'adresse est contenue dans EDI (ES:DI). Ensuite, EDI est ajusté selon la taille de l'élément transféré et l'état de l'indicateur de direction. EDI est incrémenté si DF avait été mis à 0 avec CLD ou décrémenté si DF avait été mis à 1 avec STD. Avec la forme STOS de l'instruction, un opérande doit être fourni pour indiquer la taille des éléments à copier. La dérogation de segment n'est pas permise. Lorsque l'une des formes STOSB (octets), STOSW (mots) ou STOSD (doubles mots) est utilisée, c'est le choix d'instruction qui détermine la taille des éléments de données à traiter et si l'élément provient de AL, AX ou EAX.

35 @Pierre Marchand, 200293 Écrire une chaîne (la suite) STOS/STOSB/STOSW/STOSDStore String Data STOS et ses variantes sont souvent utilisées avec le préfixe REP pour remplir une chaîne avec une même valeur. Avant d'utiliser l'instruction REP, ECX doit contenir la nombre d'itérations désiré. oszapc = oszapc stosword ptr [edi] stosb repstosw stosd

36 @Pierre Marchand, 200294 Déplacer une chaînes ou un tableaux MOVS/MOVSB/MOVSW/MOVSDMove String Data Déplace une chaîne de données d’une région de la mémoire à une autre. esi doit pointer vers la chaîne source et edi vers la chaîne destination. Pour chaque élément déplacé, edi et esi sont ajustés selon la taille des opérandes et le bit de direction DF. Dans le cas de movs, il faut fournir des opérandes pour indiquer la taille des éléments à traiter. Ces instructions sont habituellement utilisées avec le préfixe rep. oszapc = oszapc repmovsb1 movsword ptr [dest], word ptr [source]1

37 @Pierre Marchand, 200295 Exemple 02 L’exemple 02 contient différentes fonctions de traitement de chaînes de caractères et de tableaux démontrant l’utilisation des instruction que nous venons de voire.

38 @Pierre Marchand, 200296 switch switch ( i )switch: {case1:cmpi,1 case 1:…jnecase2… break;… case 2:… jmpendswitch … case2:cmpi,2 break; jnedefault default:…… }… jmpendswitch default:… endswitch:…

39 @Pierre Marchand, 200297 Optimisation des switch Dans les systèmes à base de menus, il arrive souvent qu’on ait un énoncé switch comme le suivant, où une fonction différente est exécutée suivant le choix que l’utilisateur fait dans un menu : switch (choix) { case 0:fonction1(choix); break; case 1: fonction2(choix); break; case 1:fonction3(choix); }

40 @Pierre Marchand, 200298 Tables de fonctions en C En C, on peut obtenir une meilleure performance, surtout si la liste est longue, à l’aide d’une table de pointeurs de fonctions : void (* mesFonctions [3] ) ( int ) = { fonction1, fonction2, fonction3 }; ou int (* mesFonctions [3] ) ( int ) = { fonction1, fonction2, fonction3 }; Ensuite, on peut appeler une de ces fonctions comme suit : (* mesFonctions [choix] ) ( param ); On saute directement à la bonne fonction sans avoir à parcourir le switch.

41 @Pierre Marchand, 200299 Tables de fonctions en assembleur Dans le contexte C, nous pouvons accéder à ces fonctions en assembleur comme suit : … leaeax, mesFonctions movecx, choix movebx, param pushebx call[eax+ecx*4]// * 4 car pointeur = 32 bits addesp, 4...

42 @Pierre Marchand, 2002100 Exemple 03 L’exemple 03 montre différentes implantation d’un même « switch »

43 @Pierre Marchand, 2002101 Move conditionnel CMOVCC La famille d’instructions cmovcc permet d’éviter les bran- chements dans des instructions C telles que : x = (a > b) ? 1 : -1; moveax,a movebx,b cmpeax, ebx moveax,1 movedx,-1 cmovleeax,edx// si a > b, eax contient 1 // sinon, eax contient -1

44 @Pierre Marchand, 2002102 Move conditionnel (la suite) CMOVCC L’instruction cmovcc est disponible avec toutes les conditions booléennes usuelles : cmovgreg, reg cmovgreg, mem cmovgereg, reg cmovgereg, mem cmovlreg, reg cmovlreg, mem cmovlereg, reg cmovlereg, mem etc.

45 @Pierre Marchand, 2002103 Instructions logiques

46 @Pierre Marchand, 2002104 Instructions and – or - xor AND/OR/XORLogical AND/OR/XOR Effectue une opération logique bit par bit entre l’opérande source et l’opérande destination et enregistre le résultat dans la destina- tion. oszapc = 0± ±? ±0 andreg, reg0,5 ormem, reg xorreg, mem andreg, immed ormem, immed

47 @Pierre Marchand, 2002105 Instruction not NOTOne ’s complement negation Effectue le complément logique (complément à 1) de chaque bit de la destination. oszapc = oszapc notreg0,5 notmem

48 @Pierre Marchand, 2002106 Instruction test TESTTest Teste les bits indiqués d’un opérande et positionne les indica- teurs. L’un des opérandes contient la valeur à tester. L’autre contient un masque indiquant les bits à tester. L’instruction fait le AND de la source et de la destination. Les indicateurs sont modifiés en conséquence, mais la destination n’est pas changée. oszapc = 0 ± ± ? ± 0 testreg, reg0,5 testmem, reg testreg, mem testreg, immed testmem, immed

49 @Pierre Marchand, 2002107 Instruction rol - ror ROL/RORRotate Effectue une rotation de l ’opérande destination vers la gauche ou vers la droite du nombre de bits spécifié dans l ’opérande source. Le dernier bit décalé va également dans CF. oszapc = ±szap ± ROL ROR rorreg, 1rolreg, 1 rorreg, CLrolreg, CL rormem, CLrolmem, CL rormem, immedrolmem, immed C C

50 @Pierre Marchand, 2002108 Instructions rcl - rcr RCL/RCRRotate Effectue une rotation de l’opérande destination vers la gauche ou vers la droite du nombre de bits spécifié dans l’opérande source. Cette rotation inclut le bit CF, de sorte qu’une rotation sur 9 bits est effectuée sur un registre de 8 bits, sur 17 bits pour un registre de 16 bits ou sur 33 bits pour un registre de 32 bits. oszapc = ±szap ± C C

51 @Pierre Marchand, 2002109 Instructions rcl – rcr (la suite) RCL/RCRRotate rclreg, 1 rcrmem, 1 rclmem, CL rcrreg, CL rclreg, immed rcrmem, immed

52 @Pierre Marchand, 2002110 Instructions arithmétiques

53 @Pierre Marchand, 2002111 Instruction add ADDAdd Additionne l’opérande source à l’opérande destination. oszapc =       addreg, reg0,5 addmem, reg addreg, mem addreg, immed addmem, immed

54 @Pierre Marchand, 2002112 Instruction adc ADCAdd with Carry Additionne l ’opérande source et la retenue (CF) à l’opérande destination. oszapc =       adcreg, reg8 adcmem, reg adcreg, mem adcreg, immed6 adcmem, immed

55 @Pierre Marchand, 2002113 Addition de précision L’exemple 04 démontre cette opération A 3 A 2 A 1 A 0 B 3 B 2 B 1 B 0 S 3 S 2 S 1 S 0 CF Poids faible Adresse basse Poids fort Adresse haute

56 @Pierre Marchand, 2002114 Instruction sub SUBSubtract Soustrait l’opérande source de l’opérande destination et stocke le résultat dans l’opérande destination. oszapc = ± ± ± ± ± ± subreg, reg0,5 submem, reg subreg, mem subreg, immed submem, immed

57 @Pierre Marchand, 2002115 Instructions sbb SBBSubtract with borrow Ajoute l’indicateur CF au second opérande puis soustrait cette valeur du premier opérande. Le résultat est placé dans le premier opérande. oszapc =       sbbreg, reg8 sbbmem, reg sbbreg, mem sbbreg, immed6 sbbmem, immed

58 @Pierre Marchand, 2002116 Multiplication Deux instructions : MUL pour la multiplication non signée IMUL pour la multiplication signée

59 @Pierre Marchand, 2002117 Multiplication signé et non signé Exemple: Supposons que eax = 0x80000001 eax peut être interprété comme: 2 147 483 649(non signé) ou-2 147 483 647(signé) Si ebx = 0x00000003, alors: mulebx  eax = 0x80000003 edx = 0x00000001 La réponse est le nombre 0x000000018000003, qui vaut 6 442 450 947 10.

60 @Pierre Marchand, 2002118 Multiplication signé et non signé (la suite) Multiplication signée et non signée Mais : imulebx  eax = 0x80000003 edx= 0xFFFFFFFE et la réponse est le nombre $FFFFFFE80000003, qui vaut -6 442 450 941 10. Remarquez que dans les deux cas le double mot de poids faible est le même.

61 @Pierre Marchand, 2002119 Instructions mul MULUnsigned Multiply Si l’opérande est de 32 bits, multiplie eax par l’opérande et place le résultat dans edx:eax. eax et l’opérande sont considérés comme des quantités non signées. Si l’opérande est de 16 bits, multiplie ax par l’opérande et place le résultat dans dx:ax. Si l’opérande est de 8 bits, multiplie al par l’opérande et place le résultat dans ax. Les indicateurs OF et CF sont positionnés si la partie de poids fort du résultat n’est pas nulle. oszapc = ±????± mulreg 14-18 mulmem

62 @Pierre Marchand, 2002120 Instructions imul IMULSigned Multiply Si l’opérande est de 32 bits, multiplie eax par l’opérande et place le résultat dans edx:eax. eax et l ’opérande sont considérés comme des quantités signées. Si l’opérande est de 16 bits, multiplie ax par l’opérande et place le résultat dans dx:ax. Si l’opérande est de 8 bits, multiplie al par l’opérande et place le résultat dans ax. Les indicateurs OF et CF sont positionnés si le produit est étendu en signe dans edx pour des opérandes de 32 bits, dans dx pour des opérandes de 16 bits, ou dans ah pour des opérandes de 8 bits. oszapc = ±????± imulreg14 imulmem 15-18

63 @Pierre Marchand, 2002121 Intruction imul (la suite) IMUL Deux syntaxes supplémentaires depuis le 80386. Dans la version à deux opérandes, le registre destination est multiplié par l’opérande source et le résultat est placé dans le registre destination. Dans la version à trois opérandes, les deux derniers opérandes sont multipliés ensemble et le résultat est placé dans le registre destination. Les bits OF et CF sont positionnés si le produit n’entre pas dans la destination. imulreg, immed 14 imulreg, reg imulreg, mem imulreg, reg, immed imulreg, mem, immed

64 @Pierre Marchand, 2002122 Grandeur des opérandes d’une multiplication Exemple Multiplication de deux nombres de 64 bits -> 128 bits 45 x 67 35 28 30 24 3015 XHXL YHYL 

65 @Pierre Marchand, 2002123 Multiplication de mots quadruples Composition du produit en additionnant les produits partiels de 64 bits Exemple : long A[ ] = {0xFFFFFFFF, 0xFFFFFFFF}; long B[ ] = {0xFFFFFFFF, 0xFFFFFFFF}; long Produit[ ] = {0, 0, 0, 0}; XL  YL XL  YH XH  YL XH  YH Produit de 128 bits + + + =

66 @Pierre Marchand, 2002124 Division Division signée et non signée Exemple: Supposons que eax = 0xFFFFFFF8 eax peut être interprété comme: 4 294 967 288 10 (non signé) ou-8 10 (signé) Si ebx = 0x00000003 et edx = 0x00000000, alors: divebx  eax = 0x55555552 edx = 0x00000002 qui vaut 1 431 655 762 10, reste 2.

67 @Pierre Marchand, 2002125 Division signé et non signé Division signée et non signée Mais si ebx = 0x00000003 et edx = 0xFFFFFFFF idivebx  eax = 0xFFFFFFFE, edx = 0xFFFFFFFE qui vaut -2 10, reste -2. Par contre, si ebx = 0x00000003 et edx = 0xFFFFFFFF divebx  débordement de capacité parce que le quotient est > 32 bits.

68 @Pierre Marchand, 2002126 Division signé et non signé (la suite) Division signée et non signée Avant une division non signée, si le dividende dans eax est d’une longueur inférieure ou égale à 32 bits, il faut s’assurer que edx = 0. Avant une division signée, si le dividende est d’une longeur inférieure ou égale à 32 bits, il faut s’assurer que edx est 0 si eax est positif et 0xFFFFFFFF si eax est négatif. On peut effectuer ceci automatiquement avec l’instruction cdq, qui étend eax en signe sur 64 bits dans edx. moveax, -597 movebx, 3 cdq idivebx

69 @Pierre Marchand, 2002127 Instruction div DIVDivide unsigned Si l’opérande est de 32 bits, divise eax par l’opérande et place le quotient dans eax et le reste dans edx. eax et l ’opérande sont considérés comme des quantités non signées. Si l’opérande est de 16 bits, divise dx:ax par l’opérande et place le quotient dans ax et le reste dans dx. Si l’opérande est de 8 bits, divise ax par l’opérande et place le quotient dans al et le reste dans ah. oszapc = ?????? divreg56-70 divmem

70 @Pierre Marchand, 2002128 Instruction idiv IDIVSigned Divide Si l’opérande est de 32 bits, divise eax par l’opérande et place le quotient dans eax et le reste dans edx. Les deux opérandes sont considérés comme des nombres signés. Si l’opérande est de 16 bits, divise dx:ax par l’opérande et place le quotient dans ax et le reste dans dx. Si l’opérande est de 8 bits, divise ax par l’opérande et place le quotient dans al et le reste dans ah. oszapc = ?????? idivreg56-70 idivmem

71 @Pierre Marchand, 2002129 Instructions sal - shl SALShift arithmetic left SHLShift logical left Décale les bits de l’opérande destination vers la gauche le nombre de fois spécifié par l’opérande source. L’opérande source peut être cl ou une constante de 8 bits. OF est affecté seulement lors de décalages d’un bit. Dans les autres cas, il est indéfini. oszapc =±±±?±± salreg, 1salreg, immed84 salmem,1salmem, immed8 salreg,CL salmem,CL 0 CF

72 @Pierre Marchand, 2002130 Instruction shr SHRShift logical RIGHT Décale les bits de l’opérande destination vers la droite le nombre de fois spécifié par l’opérande source. L’opérande source peut être cl ou une constante de 8 bits. OF est affecté seulement lors de décalages d’un bit. Dans les autres cas, il est indéfini. oszapc =±±±?±± shrreg, 14 shrmem,1 shrreg,CL shrmem,CL shrreg, immed8 shrmem, immed8 CF 0

73 @Pierre Marchand, 2002131 Instruction sar SARShift arithmetic right Décale les bits de l’opérande destination vers la droite le nombre de fois spécifié par l’opérande source. L’opérande source peut être cl ou une constante de 8 bits. Le bit décalé à droite est placé dans CF tandis que le bit de gauche garde sa valeur. oszapc =±±±?±± sarreg, 14 sarmem,1 sarreg,CL sarmem,CL sarreg, immed8 sar mem, immed8 CF

74 @Pierre Marchand, 2002132 Instructions shld - shrd SHLD/SHRDDouble Precision Shift Décale les bits du deuxième opérande dans le premier opérande. Le nombre de bits à décaler est spécifié par le troisième opérande. SHLD décale le premier opérande de n bits vers la gauche. Les positions laissées vacantes sont remplies par les n bits les plus significatifs du deuxième opérande. SHRD décale le premier opérande de n bits vers la droite. Les positions laissées vacantes sont remplies par les n bits les moins significatifs du deuxième opérande.

75 @Pierre Marchand, 2002133 Instructions shld – shrd (la suite) Le nombre de décalages peut être cl ou une constante de 8 bits. oszapc = ?±±? ±± shldreg, reg, immed8 shldreg, reg, CL shldmem, reg, immed8 shldmem, reg, CL

76 @Pierre Marchand, 2002134 Division binaire Donc Quotient = 0101 et Reste = 100 1 0 0 1 1 1 / 1 1 1 1 1 1 0 0 0 1 0 1 1 1 1 1 1 0 0 0 1 0 0 0 0 1 0 0 11 1 1

77 @Pierre Marchand, 2002135 Division binaire (la suite) Division binaire Division (100111 / 111) sur 6 bits RQDécalage no. 0 0 0 0 0 01 0 0 1 1 1 0 0 0 0 0 10 0 1 1 1 0Q = 01 0 0 0 0 1 00 1 1 1 0 0Q = 0 02 0 0 0 1 0 01 1 1 0 0 0Q = 0 0 03 0 0 1 0 0 11 1 0 0 0 0Q = 0 0 0 04 - 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 1 0 11 0 0 0 0 0 Q = 0 0 0 0 1 5 0 0 1 0 1 1 0 0 0 0 0 0 Q = 0 0 0 0 1 0 6 - 0 0 0 1 1 1 0 0 0 1 0 0 Q = 0 0 0 0 1 0 17

78 @Pierre Marchand, 2002136 Division binaire (la suite) Division Principe Pour plus de détails, voir le chapitre 1 du cours Structure Interne des ordinateurs. Initialement, R = 0 et Q = Dividende; D est le diviseur. On décale Q dans R un bit à la fois. Si R ≥ D, on effectue R = R - D et on passe 1 à droite du quotient, sinon on passe 0. On répète ceci autant de fois qu’il y a de bits dans le registre Q, par exemple, 16 ou 32 fois. RQ 1 si R ≥ D

79 @Pierre Marchand, 2002137 Division binaire (la suite) Division Finalement, on décale Q une dernière fois à gauche. À la fin de l’opération, R contient le reste et Q le quotient. On peut effectuer cet algorithme sur des opérandes de plusieurs mots, par exemple Q = 64 bits et R = 64 bits, etc.

80 @Pierre Marchand, 2002138 Division de précision Division Division 128 bits par 64 bits Pour effectuer cette opération, on a besoin des fonctionnalités suivantes (fonctions ou macros) : longShiftLeft(src, dwords, shifts) longCompare(dst, src, dwords) longSub(dst, src, dwords) R Q 1 si R ≥ D RR+4Q+8Q+12Q+4Q D DD+4

81 @Pierre Marchand, 2002139 Instructions neg NEGNegate Remplace l’opérande par son complément à 2. En fait, NEG effectue l’opération 0 - opérande. Si l ’opérande est 0, CF = 0, sinon CF = 1. Si l ’opérande contient -128 pour 8 bits, -32,768 pour 16 bits ou - 2,147,483,648 pour 32 bits, alors sa valeur ne change pas, mais OF et CF deviennent 1. oszapc = ± ± ± ± ± ± negreg0,5 negmem