Diapositives sur l`assembleur
publicité
Assembleur INF1600: Architecture des micro-ordinateurs Assembleur Introduction à IA-32 Responsable du cours : Giovanni Beltrame [email protected] Local: M-4109 Chargée de cours: Luiza Gheorghe [email protected] Génie informatique et génie logiciel 1 H2015 3 Assembleur Conventions du C • Les variables globales sont dans la section .data • Les variables locales et paramètres sont sur la pile – En C les paramètres sont empilés de droite à gauche avant le ‘call’ (dépilés au retour du ‘call’) – L’espace pour les variable est alloué au début de la sous-routine – On utilise souvent %ebp pour pointer vers ces variables/paramètres • La valeur de retour – Dans %eax pour les entiers (char/short/int…) et pointeurs (edx:eax pour 8 octets) – Dans %st(0) pour les float/double (registres larges pour operations point flotant) – En mémoire pour les objets/structures • Le pointeur où placer le résultat est donné par la routine appelante • Registres qu’ une routine peut modifier: %eax, %ecx, %edx – Doit sauver/restaurer les autres si on les modifies Génie informatique et génie logiciel 2 H2015 Assembleur La pile – paramètres, valeurs, variables Cadre pile procedure 1 (stack frame) Génie informatique et génie logiciel 3 H2015 Assembleur La pile – l’instruction swap void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } swap: pushl %ebp movl %esp,%ebp pushl %ebx movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret Génie informatique et génie logiciel prologue corps (code, etc) epilogue 4 H2015 Assembleur void swap(int *xp, int *yp) { int t0 = *xp; int t1 = *yp; *xp = t1; *yp = t0; } Offset Variable yp xp t1 t0 yp 8 xp 4 ad. ret. ancien %ebp ancien Génie informatique et génie logiciel -4 movl movl movl movl movl movl Pile 12 0 Registre %ecx %edx %eax %ebx • • • 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) %ebx # ecx # edx # eax # ebx # *xp # *yp = = = = = = %ebp yp xp *yp (t1) *xp (t0) eax ebx 5 H2015 Adresse Assembleur pushl %ebp movl %esp,%ebp pushl %ebx %eax 0x124 456 0x120 0x11c 0x118 Offset %edx %ecx %ebx 0x114 yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 123 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 6 H2015 Adresse Assembleur 123 0x124 456 0x120 0x11c %eax 0x118 Offset %edx %ecx 0x120 %ebx yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 0x114 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 7 H2015 Adresse Assembleur 123 0x124 456 0x120 0x11c %eax 0x118 %edx 0x124 %ecx 0x120 Offset %ebx yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 0x114 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 8 H2015 Adresse Assembleur 123 0x124 456 0x120 0x11c %eax 456 %edx 0x124 %ecx 0x120 0x118 Offset %ebx yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 0x114 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 9 H2015 Adresse Assembleur 123 0x124 456 0x120 0x11c %eax 456 %edx 0x124 %ecx 0x120 %ebx 0x118 Offset 123 yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 0x114 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 10 H2015 Adresse Assembleur 456 0x124 456 0x120 0x11c %eax 456 %edx 0x124 %ecx 0x120 %ebx 0x118 Offset 123 yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 0x114 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 11 H2015 Adresse Assembleur %eax 456 %edx 0x124 %ecx 0x120 %ebx movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret 0x124 123 0x120 0x11c 0x118 Offset 123 0x114 yp 12 0x120 0x110 xp 8 0x124 0x10c 4 Ad ret 0x108 %esi 0 %ebp %edi 0x104 -4 %esp %ebp 456 0x104 movl movl movl movl movl movl 12(%ebp),%ecx 8(%ebp),%edx (%ecx),%eax (%edx),%ebx %eax,(%edx) %ebx,(%ecx) Génie informatique et génie logiciel # # # # # # ecx edx eax ebx *xp *yp 0x100 = = = = = = yp xp *yp (t1) *xp (t0) eax ebx 12 H2015 Assembleur La pile – paramètres, valeurs, variables Génie informatique et génie logiciel 13 H2015 Assembleur La pile – paramètres, valeurs, variables Responsabilités “caller” (main) - push les paramètres en ordre inverse (le dernier dans la pile le premier) - call - pop les paramètres (pop ou incrémentation %esp pour les enlever) - la valeur de retour en %eax Responsabilités “callee” (procédure) - stocke %ebp d’appeleur dans la pile # prologue procédure push %ebp - sauvegarde le %esp courant dans %ebp # prologue procédure mov %esp, %ebp - codage, stockage variables locales dans la pile - sortie rapide – load %esp de %ebp (sinon pop élément par élément) #épilogue procédure mov %ebp, %esp # retour aux valeurs initiales (clean up) pile - pop ancien %ebp et return – stocke valeur de retour en %eax #épilogue procédure pop %ebp # retour aux valeurs initiales (clean up) pile Génie informatique et génie logiciel 14 H2015 Assembleur Génie informatique et génie logiciel 15 H2015 Assembleur IA32/Linux Utilisation de registres Usage special %eax %ebp, %esp Caller- pour temporaires Callee %edx %ebx, %esi, %edi %ecx Anciennes valeurs sur la pile avant de les utiliser Callee- pour temporaires %ebx %esi Caller %eax, %edx, %ecx %edi %esp Registre %eax valeur de retour Génie informatique et génie logiciel Special %ebp 16 H2015 Assembleur int rfact(int x) { int rval; if (x <= 1) return 1; rval = rfact(x-1); return rval * x; } Génie informatique et génie logiciel rfact: pushl %ebp movl %esp,%ebp pushl %ebx movl 8(%ebp),%ebx cmpl $1,%ebx jle .L78 leal -1(%ebx),%eax pushl %eax call rfact imull %ebx,%eax jmp .L79 .align 4 .L78: movl $1,%eax .L79: movl -4(%ebp),%ebx movl %ebp,%esp popl %ebp ret 17 H2015 Assembleur Recursion movl 8(%ebp),%ebx cmpl $1,%ebx jle .L78 leal -1(%ebx),%eax pushl %eax call rfact imull %ebx,%eax jmp .L79 .L78: # movl $1,%eax .L79: # int rfact(int x) { int rval; if (x <= 1) return 1; rval = rfact(x-1) ; return rval * x; } Génie informatique et génie logiciel # ebx = x # Comp x - 1 # If <= goto Term # eax = x-1 # Push x-1 # rfact(x-1) # rval * x # Goto done Term: # return val = 1 Done: Registers %ebx Valeur of x %eax Val temp x-1 Val retour rfact(x-1) Valeur de retour de l’appel 18 H2015 Assembleur eflags CF ZF Carry Flag Zero Flag SF OF Sign Flag Overflow Flag Implicitement modifiés par des opérations arithmétiques addl Src,Dest C analogue: t = a + b; b = t; CF =1 si carry out du MSB ZF =1 si t == 0 SF = 1 si t < 0 OF = 1 si débordement complément à deux (a>0 && b>0 && t<0) || (a<0 && b<0 && t>=0) Non modifiés pas l’instruction leal Génie informatique et génie logiciel 19 H2015 Assembleur Explicitement modifiés par l’instruction de comparaison cmpl Src2,Src1 cmpl b,a comme a-b sans destination CF = 1 si carry out du MSB ZF = 1 si a == b SF =1 si (a-b) < 0 OF = 1 débordement complément à deux (a>0 && b<0 && (a-b)<0) || (a<0 && b>0 && (a-b)>0) Explicitement modifiés par l’instruction de test testl Src1,Src2 testl a,b comme a&b sans destination ZF = 1 si a&b == 0 SF = 1 si a&b < 0 Génie informatique et génie logiciel 20 H2015 4 Assembleur Opérations arithmétiques : additions Affectent tous eflags selon le résultat de l’opération • add source, dest dest ← dest + source (M, R; R, M; R,R) • adc source, dest dest ← dest + source + CF • sub source, dest dest ← dest – source • sbb source, dest dest ← dest – source – CF Eflag affectés: OF, SF, ZF, PF, CF, AF • • cmp source, dest dest – source (seulement eflag est affecté) • neg dest dest ← 0 – dest (M; R - SF, ZF, PF, CF, AF ) inc dest dest ← dest + 1 (M; R) • dec dest dest ← dest – 1 (M; R ) Eflag affectés: OF, SF, ZF, PF, AF • Génie informatique et génie logiciel 21 H2015 Assembleur Branchement Exemple cmpl b,a comme a-b sans destination _max: pushl %ebp movl %esp,%ebp int max(int x, int y) { if (x > y) return x; else return y; } movl 8(%ebp),%edx movl 12(%ebp),%eax cmpl %eax,%edx jle L9 movl %edx,%eax Ignoré si x ≤ y L9: movl %ebp,%esp popl %ebp ret Génie informatique et génie logiciel 22 H2015 Assembleur “Do-While” Loop Assembleur Goto int fact_goto (int x) { int resultat = 1; loop: resultat *= x; x = x-1; if (x > 1) goto loop; return resultat; } Registres %edx x %eax resultat _fact_goto: pushl %ebp movl %esp,%ebp movl $1,%eax movl 8(%ebp),%edx # # # # prologue prologue eax = 1 edx = x L11: imull %edx,%eax decl %edx cmpl $1,%edx jg L11 # # # # resultat *= x x-x - 1 if > goto loop movl %ebp,%esp popl %ebp ret Génie informatique et génie logiciel # epilogue # # 23 H2015 5 Assembleur Boucles •Instructions spéciale: loop, loopz, loopnz ― N’affectent pas eflags ― loop quelquepart ecx ← ecx – 1 ; (ecx ≠ 0) → (eip ← quelquepart) ― loopz quelquepart ecx ← ecx – 1 ; (ecx ≠ 0 ∧ ZF = 1) → (eip ← " ) ● Pour « loop while zero » ― loopnz ● quelquepart ecx ← ecx – 1 ; (ecx ≠ 0 ∧ ZF = 0) → (eip ← " ) Pour « loop while not zero » •Exemple: mov $16,%ecx mov $chaine,%ebx L1: incl %ebx cmpb $' ', (%ebx) loopz L1 # nombre de répétitions maximal # %ebx contient l'adresse d’une chaîne de caractères # caractère suivant # aussi i++ # est-ce un espace ? Si oui ZF=1, sinon ZF=0 # saute si ZF=1 et décompte pas fini Génie informatique et génie logiciel 24 H2015 Assembleur INF1600: Architecture des micro-ordinateurs Assembleur Arithmétique, logique et directives Responsable du cours : Giovanni Beltrame [email protected] Local: M-4109 Chargée de cours: Luiza Gheorghe [email protected] Génie informatique et génie logiciel 25 H2015 Assembleur Programme du cours 07/01/2016 Introduction 29/01/2016 Organisation interne du microprocesseur Lien entre C++ et assembleur TP2 TP0 Architecture du microprocesseur Hierarchie de mémoire 04/02/2016 – 18/02/2016 TP5 Programmation en assembleur Mémoires Introduction aux outils 14/01/2016 Micro-ordinateur et périphériques TP4 TP1 TP3 Périphériques et architecture Programmation en assembleur 22/01/2016 Architecture d'un microprocesseur Génie informatique et génie logiciel C++ et assembleur Théorie Travaux Pratiques 26 H2015 Assembleur Objectifs de la leçon 1 Utiliser les opérations arithmétiques (multiplication et division) de l'architecture x86 2 Utiliser les opérations logiques (xor,and,or,...) de l'architecture x86 3 Utiliser les opérations de décalage (shr, shl,...) de l'architecture x86 4 Utiliser les instructions sur les indicateurs de l'architecture x86 5 Utiliser les directives de l'assembleur x86 Génie informatique et génie logiciel 27 H2015 Assembleur Agenda • Instructions • Diréctives 4 • Exemple 5 Génie informatique et génie logiciel 1 2 3 28 H2015 %eax %ah %al %edx %dh %dl %ecx %ch %cl %ebx %bh %bl Assembleur Opérations arithmétiques : multiplications ● mul source8 ax ← al * source8 (non signé) ● mul source16 dx#ax ← ax * source16 %edi ● mul source32 edx#eax ← eax * source32 %esp 1 %esi %ebp ● ● Attention – dans cette forme ● source ne peux pas être immédiate ● edx, dx ne peuvent pas être immédiat CF et OF si résultat prend plus de place que la source Génie informatique et génie logiciel 29 H2015 Assembleur Opérations arithmétiques : multiplications ● imul source8 … ● imul source16 … ● imul source32 … ● imul source, dest dest ← dest * source ● imul const, source, dest dest ← const * source (même chose mais signé) – const est immédiat; source est registre ou mémoire; dest est registre Génie informatique et génie logiciel 30 H2015 %eax %ah %al %edx %dh %dl %ecx %ch %cl %ebx %bh %bl Assembleur Opérations arithmétiques : divisions ● div source8 al ← ax / source8 : (non signé) ● ah ← ax mod source8 %esi div source16 ax ← dx#ax / source16 : %edi dx ← dx#ax mod source16 %esp div source32 eax ← edx#eax / source32 : %ebp edx ← edx#eax mod source32 Attention source – registre ou mémoire mais non immédiate edx, ed ne peuvent pas être immédiate idiv source8 … (même chose mais signé) idiv source16 … idiv source32 … ● N’existe pas: idiv source, dest ● ● ● ● ● Génie informatique et génie logiciel 31 1 H2015 1 Assembleur Exemple de multiplications .data unword: .word 20 .text .global main main: mov $3,%ax mov $5, %bx mov $10, %dx mul %bx mulw unword mov $255,%bl mov $2,%al mul %bl mov $2,%al imul %bl mov $10, %bx imul %ax, %bx ret # section initialisé, lisible, écrivable # section lisible, exécutable, non écrivable # la valeur de %dx sera écrasée # dx ← 0 : ax ← 15 : CF ← 0 : OF ← 0 # dx ← 0 : ax ← 300 : CF ← 0 : OF ← 0 # ax ← 1FE16 (ou 51010) : CF ← 1 : OF ← 1 # (car résultat n’entre pas dans %al) # Note: 255 sur 8-bits est -1 en signé # ax ← FFFE16 (ou -2) : CF ← 0 : OF ← 0 # bx ← -20 : CF ← 0 : OF ← 0 Génie informatique et génie logiciel 32 H2015 1 Assembleur Exemple de divisions .data unword: .word 20 .text .global main main: mov $0,%dx mov $78, %ax mov $5, %bx div %bx # section initialisé, lisible, écrivable # section lisible, exécutable, non écrivable # ax ← 15 : dx ← 3 mov $0,%dx mov $122,%ax divw unword # ax ← 6 : dx ← 2 mov $10, %bx ((dx#ax)/bx donne 15 reste 3) ((dx#ax)/M16[unword] donne 6 reste 2) mov $0xffff,%dx mov $0xffff,%ax mov $3,%bx #div %bx #Divide Error (débordement) ret Génie informatique et génie logiciel 33 H2015 2 Assembleur Instructions logiques ● Affectent eflags selon le résultat – OF ← 0 : CF ← 0 : SF ← résultat⟨31⟩ : ZF ← (résultat=0) : PF ← ((nombre de bits à 1 dans résultat) +1) mod 2 ● Opérations bit par bit – (A#B#C) ⊗ (D#E#F) = (A⊗D)#(B⊗E)#(C⊗F) ● or source, dest dest ← dest ∨ source – Peut servir à forcer des bits à 1 ● and source, dest dest ← dest ∧ source – Peut servir à forcer des bits à 0 ● xor source, dest dest ← dest ⊕ source – Peut servir à inverser des bits – Peut servir à mettre à 0 un registre: xor %eax, %eax Génie informatique et génie logiciel 34 H2015 2 Assembleur Exemple d’opérations logiques .data nombre: .byte 6 lettre: .string “BONJOUR” .text .global main main: mov nombre,%al or $’0’, %al and $0xF, %al # chaque lettre prend un octet #6 # ‘6’, aurait pu faire add $’0’,%al aussi # 6, prend les 4 bits de poids faible # le code suivant suppose que c’est une lettre (‘A’-’Z’ ou ‘a’-’z’) mov lettre+2,%al # ‘N’ ASCII ‘N’ – 78 (4E) xor $0x20,%al # ‘n’, change majuscule ↔ minuscule and $~0x20,%al # ‘N’, force majuscule or $0x20,%al # ‘n’, force minuscule ASCII ‘n’ 110 (6E) ret Génie informatique et génie logiciel 35 H2015 3 Assembleur Instructions de décalage ● ● ● Affectent eflags (CF, OF, ZF) ● CF ← dernier bit sorti ● Si source est $1, OF ← résultat<signe> != valeur_décalée<signe> Opérandes ● Source: immédiat ou %cl ● Dest: registre ou mémoire(8, 16 ou 32 bits) Décale d’un maximum de 32 bits ● ● Shift right sar source, dest – dest#CF ← src5@dest<31> # dest<31..src5-1> ● ● src5 := source<4..0> shr source, dest – dest#CF ← src5@0 # dest<31..src5-1> ● ● Décale de src5 bits Shift arithmetic right shrd source, source2, dest dest#CF ← source2<src5-1..0> # dest<31..src5-1> ● source2 doit être registre Génie informatique et génie logiciel 36 H2015 3 Assembleur Instructions de décalage ● ● ● ● ● ● ror source, dest – Rotate right dest#CF ← dest⟨src5-1..0⟩ # dest⟨31..src5-1⟩ rcr source, dest dest#CF ← (dest#CF)⟨src5-1..0⟩ # (dest#CF)⟨32..src5⟩ – Rotate (through) carry right shl source, dest CF#dest ← dest⟨32-src5..0⟩ # src5@0 – Shift (arithmetic) left (sal := shl) shld source, source2, dest CF#dest ← dest⟨32-src5..0⟩ # source2⟨31..32-src5⟩ rol source, dest – Rotate left CF#dest ← dest⟨32-src5..0⟩ # dest⟨31..32-src5⟩ rcl source, dest CF#dest ← (CF#dest)⟨32-src5..0⟩ # (CF#dest)⟨32..33-src5⟩ – Rotate (through) carry left Génie informatique et génie logiciel 37 H2015 3 Assembleur Exemple de décalage .text .global main main: mov $0b11110111,%al sar $1, %al shl $1, %al shl $5, %al rol $1, %al mov $4, %cl rcl %cl, %al mov $0x12345678, %eax ror $8, %eax mov $0xABCDEF00, %edx shld $12, %edx, %eax ret Génie informatique et génie logiciel # al ← 111110112 : CF ← 1 : OF ← 0 # al ← 111101102 : CF ← 1 : OF ← 0 # al ← 110000002 : CF ← 0 # al ← 100000012 : CF ← 1 : OF ← 0 # al ← 000111002 : CF ← 0 # eax ← 7812345616 : CF ← 0 # eax ← 23456ABC16 : CF ← 1 38 H2015 4 Assembleur Instructions sur les indicateurs ● ● ● ● ● ● ● ● ● stc clc cmc cld std pushf popf lahf sahf CF ← 1 (set carry) CF ← 0 (clear carry) CF ←!CF (complement carry) DF ← 0 (clear direction, direction positive) DF ← 1 (set direction, direction négative) push(eflags) (push flags) eflags ← pop (pop flags) AH ← eflags<7..0> (load ah flags) eflags<7..0> ← AH (store ah flags) Génie informatique et génie logiciel 39 H2015 Assembleur Agenda • Instructions • Diréctives 4 • Exemples 5 Génie informatique et génie logiciel 1 2 3 40 H2015 4 Assembleur Directives ● Remplissage de mémoire – .fill répétitions, NBoctets, valeur(=0) – .skip répétitions, valeur Équivalent à .fill répétitions, 1, valeur .space synonyme de .skip ● Alignement – .balign val1, val2(=0 ou nop), val3(=infini) Aligne sur un multiple de val1 en utilisant val2 pour remplir Si le nombre d’octet à placer n’est pas > val3 – .p2align val1, val2, val3 Fait un .balign 2val1, val2, val3 ● Alignement selon Intel (recommandations) – Aligner les données sur des multiples de leur taille – Aligner les étiquettes du code, sur 16 octets, si c’est a moins de 8 octets Étiquette de boucle Étiquette suit un saut inconditionnel Génie informatique et génie logiciel 41 H2015 Assembleur Agenda • Instructions • Diréctives 5 • Exemples 3 4 5 Génie informatique et génie logiciel 1 2 3 4 42 H2015 3 Assembleur 4 Exemple : renverse .text .global renverse .p2align 4 renverse: mov 4(%esp), %al mov $8,%ecx xor %bl, %bl .p2align 4, , 7 boucle: shl $1,%al rcr $1,%bl loop boucle mov %bl, %al ret Génie informatique et génie logiciel # l’argument (ex.: 110111002) # valeur de retour (ex.: 001110112) 43 H2015 Assembleur 3 5 4 Exemple : lecture d’un nombre binaire .text .global inbin # lire un nombre binaire sur 32 bits et validation # entrée: EBX = l'adresse de la chaîne de caractères contenant des '0' et '1' # sortie: EAX = le nombre # CF = 1 si on a des lettres différentes de '0' ou '1' # ou si le nombre de bits dépasse 32 # ne modifie aucun registre inbin: push %ebx push %ecx push %edx xorl %edx,%edx xorl %eax,%eax xorl %ecx,%ecx # nombre de chiffres Génie informatique et génie logiciel 44 H2015 3 Assembleur 4 5 Exemple : lecture d’un nombre binaire (suite) trouve: mov (%ebx),%al cmp $'\n', %al je termine cmp $'1', %al je suite cmp $'0',%al je suite jmp nonbin suite: cmp $32,%ecx ja nonbin and $0xF,%eax shl $1,%edx or %al,%dl inc %ecx inc %ebx jmp trouve Génie informatique et génie logiciel # prendre un caractère # fin de la ligne? # chiffre 0 ou 1 #jump if above 45 H2015 Assembleur 3 4 5 Exemple : lecture d’un nombre binaire (suite) termine: mov pop pop pop ret %edx, %eax %edx %ecx %ebx nonbin: # il y a une erreur dans le code… xor %eax, %eax stc # set carry, CF ← 1 jmp termine Génie informatique et génie logiciel 46 H2015 Assembleur Agenda • Instructions • Diréctives 5 • Exemples 3 4 5 Génie informatique et génie logiciel 1 2 3 4 47 H2015 Assembleur Synthèse 1 Utiliser les opérations arithmétiques (multiplication et division) de l'architecture x86 2 Utiliser les opérations logiques (xor,and,or,...) de l'architecture x86 3 Utiliser les opérations de décalage (shr, shl,...) de l'architecture x86 4 Utiliser les instructions sur les indicateurs de l'architecture x86 5 Utiliser les directives de l'assembleur x86 Génie informatique et génie logiciel 48 H2015
