Pas A Pas L'assembleur

Table des matires
Introduction......6 Assembleur, philosophieet atouts ...8 Avantages et inconvnients de lassembleur...9 Que programmer en Assembleur ? .10
Chapitre 1 : Notions de base....10 Les systmes de numration......10 Dcimale.11 Binaire....11 Octal13 Hexadcimale..13 Les conversions entre bases numrales..14 Dcimale Binaire..14 Binaire Dcimale.16 Binaire Hexadcimale16 Hexadcimale Binaire 17 Ya tils des nombres ngatifs en binaire ?......17 Oprations Arithmtiques ....19 Laddition...................19 La soustraction20 Astuce20
By: Lord Noteworthy / FAT Assembler Team
Page 2
Chapitre 2 : Organisation de l'Ordinateur21 Un microprocesseur, en deux mots.....22 Historique..22 Notations...................25 Le mode de fonctionnement des x86.....26 Organisation interne du microprocesseur...27 Registres gnraux...29 Registres de segments....31 Registres doffset...31 Registre de flag..32 Les registres MMX et SIMD...32 Les registres spcialis.s ..33 La pile33 La mmoire..................34 La pagination mmoire.......................34 Organisation de la mmoire35
Chapitre 3 : Instruction du microprocesseur..37 Anatomie dun programme en assembleur....37 Structure des instructions.37
Page 3
tiquette.38 Mnmonique.38 Oprandes.38 Ecrire des commentaires dans le programme39 Lisibilit et prsentation.39 Notes et abrviations.40 Oprandes.....................41 Liste des instructions par fonctionnalits..41 Instructions de dplacement et daffectation.....42 Instructions logiques et arithmtiques..42 Instructions de manipulation de bits........42 Instructions de dcalage...43 Instructions de traitement..............43 Instructions de contrle et de test.43 Saut inconditionnel.................43 Saut conditionnel....44
Chapitre 4 : Les outils ncessaires au programmeur.46 Bon, de quoi d'autre a-t-on besoin ? .47
Page 4
Installation de Masm...51 Configuration de RadAsm....................53 Crer son premier projet..57 Prsentation rapide de l'interface..60 Squelette dun programme en Assembleur.63
Chapitre 5 : Lenvironnement Windows......65
Chapitre 6 : Structure de donnes70 Les variables et les constantes..................70 Porte des variables..73 Directive ALIGN...73 Directive dgalit (=)...76 Loprateur PTR..................77 Loprateur TYPE...78 Les tableaux.78 Loprateur LENGTHOF80 Les structures..80 Les unions.82 Les pointeurs...83 Les oprateurs ADDR & OFFSET84 Les crochets.85
Page 5
Chapitre 7 : Principe de base de la programmation Windows.88 Programmation vnementielle...89 Communication par le biais de message....89 La notion dindpendance vis--vis des priphriques..90 Stockage des informations des programmes sous forme de ressources.....90 Des types de donnes tranges90 Convention spciale de nommage.91 La programmation Windows en pratique..91
Chapitre 8 : Une simple fentre.92 La classe de fentre..93 Cration dune fentre...98 Les Tests.................102 La directive conditionnelle .IF ............102
Gnration automatique du code ASM..103 Comparaison signes et non signs..103 Comparaisons d'entiers signs.103 Comparaisons de registres104 Expressions composes.104 Les boucles.105 Directives .REPEAT et .WHILE.............106 Sortir de la boucle107
Page 6
La directive Goto..107 Traitement des messages..108 La procdure de fentre.....................109
Conclusion et remerciement..137 Annexes......138
Page 7
Bonjour et bienvenue dans ce Guide ! Je me nomme Lord Noteworthy et je suis lauteur de ce Guide. galement le webmaster du site
http://LordNoteworthy.c.la .
Alors a y est ? Vous avez dcid de se lancer la programmation en Assembleur mais vous ne savez pas trop par o commencer ? Bon, je vais essayer de vous donner quelques bases, ce qui croyezmoi, n'est pas vident ... Mon obsession pour lAssembleur ma normment incit cerner ce qui est juste savoir, car pour tout expliquer, cela demanderait quelque milliers de pages, crites en tous petits caractres. Nanmoins, partir de nombreux exemples, vous allez vous familiariser avec la syntaxe de ce langage et apprendre travailler avec les instructions. Vous ferez connaissance de quelques principes de base sur larchitecture des systmes informatiques, dans le cadre concret de la famille des processeurs IA-32 Intel et renforcerez vos comptences sur la syntaxe MASM. Enfin vous aurez un aperu de larchitecture Win32. Il nest nullement indispensable davoir une certaine exprience en programmation pour tirer parti de ce Guide, seulement de la patience, de la volont, de la dtermination dapprendre et de comprendre. Certes si vous avez touch tout autre langage de haut niveau que l'assembleur, vous allez vous sentir plus laise, hors langages de balisage tels que lHTML ne vous servira surtout pas. Pour finir je tiens prciser certaines petites choses. Tout dabord ce texte, beaucoup de personne auraient pu lcrire. De plus je ne suis pas parfait, il n'est pas improbable que ce Guide contienne quelques erratas, des incohrences ou d'autres petites choses qui m'auraient chappes, si vous en dcelez une, merci de m'en faire part pour que je les corrige au plus vite possible. Bon, eh bien sur ce, bonne lecture, et bon apprentissage tous, en gardant l'esprit la profonde maxime du regrett professeur Shadoko : La plus grave maladie du cerveau, c'est de rflchir .
Introduction
Le dbut du document aborde des notions importantes en Assembleur et ncessaires pour bien comprendre la suite. Vous serez sans doute un peu du de ne pas faire des choses extrmement puissantes immdiatement, mais patience : qui veut aller loin mnage sa monture. Ainsi, avant de nous
Page 8
plonger dans les arcanes de la programmation en Assembleur au sens large du terme, nous allons commencer par poser un certain nombre de bases. Contrairement ce qu'on dit souvent, un ordinateur ce n'est pas une machine trs intelligente, c'est une machine qui donne lillusion dtre intelligente car elle calcule trs vite, part a, un ordinateur a ne sait faire que des calcules trs simple, encore pas avec tous les chiffres, mais uniquement deux chiffres, le 0 et le 1. Le langage de chaque ordinateur est le langage machine o les instructions et les donnes sont reprsentes par des combinaisons de bits, les fameux zros et uns. Lorsquun ordinateur traite du texte, du son, de limage, de la vido, il traite en ralit des nombres. Les langages de programmation ont considrablement volu depuis les premiers calculateurs labors pour assister les calculs de trajectoire dartillerie durant la seconde guerre mondiale. A cette poque l, les programmeurs travaillaient en langage machine, ce qui consistait grer des chaines trs longues composes de 1 et de 0, ce fut un vritable travail de fourmi. Bientt, les premiers assembleurs rendirent les instructions machine plus intelligibles et plus facile utiliser. Dans les annes soixante, pour faciliter encore la programmation, on a mis en place d'autres langages de programmation plus abordables, plus comprhensible par lhumain, ces langages sont dits volus parce quils donnent la possibilit aux programmeurs dutiliser une syntaxe proche de la langue anglaise, avec des instructions et des mots comme let variable = 10. Dans des discussions passionnes sur les comptences de chacun, il est rare que quelqu'un ne sorte pas l'idiotie suivante : Le langage machine c'est plus rapide que l'assembleur ! Ou pire encore : L'assembleur, c'est gnial, c'est plus rapide que le langage machine ! Rassurer vous, si vous avez faire ce genre de personnes, ne vous sentez pas ignorant, il s'agit de personnes qui ne savent pas de quoi elles parlent, et qui se permettent de porter des jugements. Le langage machine c'est exactement la mme chose que l'assembleur, seule l'apparence diffre. Je m'explique. Si vous voulez mettre la valeur 5 dans EAX vous taperez :
Nessayer pas den comprendre le contenu, vous navez mme pas encore abord la chapitre 1. Cette instruction en assembleur sera quelque chose qui ressemble a en binaire : 1100110 10111000 101
Page 9
Quand votre microprocesseur rencontrera la valeur binaire 1100110 10111000, il saura quil s'agit de l'instruction MOV EAX, ? Et que vous allez lui fournir la suite une valeur immdiate qu'il devra mettre dans EAX. Si vous aviez tap directement les bits un un, le rsultat aurait t exactement le mme, vous auriez simplement beaucoup souffert pour rien, vous auriez alors programm en langage machine. L'assembleur, se limite en fait directement transcrire en code machine votre programme assembleur. L'assembleur ne modifiera en rien vos initiatives, la vitesse d'excution est donc exactement la mme, que le programme ait t programm en langage machine bit par bit, ou en assembleur. Si par contre, vous programmez en Pascal ou en langage C, vous ne saurez pas ce que le compilateur fera de votre programme quand il le transformera en un programme machine directement comprhensible par le microprocesseur. Vous verrez, que, quand vous programmerez si par mgarde vous allez continuer l'excution de votre programme dans des donnes, le microprocesseur se retrouvera alors avec des instructions incohrentes, et plantera assez vite. Comme vous avez pu le constater, tout cela nas rien de sorcier, le binaire que traite lordinateur avec facilit ne convient pas au programmeur qui commet souvent, par manque dattention, des erreurs trs difficiles ensuite dtecter, les nombres binaires se ressemblent, surtout aprs travaill avec eux pendant plusieurs heures, prtant confusion et sans signification apparente. Il parait donc vident que ce type d'criture est difficilement lisible pour nous, tre humains.... Un programmeur pourra tenter de se souvenir de quelques codes binaires mais il pourrait investir ses efforts dans des tches plus productives. Lide vient davoir un programme qui effectue la traduction langage assembleur langage machine, cest ce programme qui est appel lassembleur. Il est bien sur possible de traduire un programme crit en assembleur la main en remplaant chaque instruction son quivalente en binaire ; cest ce quon lappelle lassemblage manuel, mais croyez moi nombreuses sont les difficults associes cette conversion. Voici un petit exemple :
Page 10
Haut niveau Langage humain : (Par exemple, langlais)
If the line is not busy, connect to the internet; Else, wait
Langage de programmation : Haut niveau (Par exemple, le C)
If (line ! = busy) connect (Internet); Else wait (5)
Compilation
Langage de programmation : (lAssembleur)
CMP EAX, EBX JNE Failed ; JMP end Failed: End:
Langage Machine : (code binaire)
Assemblage
01010111010101001110101010101 01011111010100010101010111111 01010101010001000000101011110 10101010111010101011010101001
Bas niveau Demble on comprend mieux lintrt de lassembleur et des langages volus qui soulagent les programmeurs d'un fardeau norme, et qui prsentent une facilit de programmation bien plus grande que le langage machine.
Assembleur, philosophie et atouts Lassembleur abrg ASM est le langage de programmation (un code de communication, permettant un tre humain de dialoguer avec sa machine) de plus bas niveau. Cela signifie quil est trop proche du matriel, qui oblige le programmeur se soucier de concepts proches du fonctionnement de la machine, comme la mmoire. Heureusement, ils existent des langages hauts niveau, linstar de Visual Basic, Delphi, C++, Java..., ce sont les langages les plus utiliss de nos jours, qui permettent au programmeur de s'abstraire de dtails inhrents au fonctionnement de la machine. Il permet de manipuler des concepts bien plus
Page 11
labors. En fait, les avantages qui offrent les langages haut niveau sont normes: Ils assurent une meilleur portabilit, c'est--dire que l'on pourra les faire fonctionner sans gure de modifications sur des machines ou des systmes d'exploitation diffrents, lcriture dun programme est beaucoup plus facile et prend donc beaucoup moins de temps, la probabilit dy faire des fautes est nettement plus faible, la maintenance et la recherche des bugs sont grandement facilits. Si nous rsumons, le terme "Assembleur" dsigne tour tour deux choses diffrentes, mais apparentes : le langage de programmation de plus bas niveau accessible facilement un humain et un logiciel transformant un fichier source contenant des instructions, en un fichier excutable que le processeur peut comprendre. Avantages et inconvnients de lassembleur Evidemment, rien n'est parfait. Jetons un petit coup d'il sur le revers de la mdaille: Le programme est long et fastidieux crire. Les programmes crits en assembleur sont trs peu portables vers une autre architecture, existante ou future. Programmer en assembleur est rserv aux dveloppeurs chevronns. Raliser un programme complet avec demande normment d'efforts et d'exprience. Difficult de localisation d'erreurs au cours de la mise au point du programme. Pendant longtemps, la principale proccupation des programmeurs tait de concevoir des applications trs courtes pouvant sexcuter rapidement. Il faut dire que la mmoire cotait chaire, tout comme le traitement de la machine. Avec la miniaturisation des ordinateurs, laugmentation de leur performance et la chute des prix, les priorits ont chang. A lheure actuelle, le cot de dveloppement dpasse largement celui dun ordinateur, limportant de faire des programmes performants, bien construis et faciles mettre jour, on na plus besoin dutiliser lassembleur Comme tout langage de programmation, lassembleur a ses inconvnients, mais aussi ses avantages: Tous les langages de programmation sont des hritiers plus ou moins directs de ce langage lmentaire quest lassembleur, ce dernier peut vous donner la logique ncessaire pour programmer en nimporte quels langages, ce langage trouve sa place dans l'ensemble des applications, sans oublier que n'importe quel programme, crit dans n'importe quel langage est finalement traduit en langage machine pour tre excut. On a la possibilit de faire tout et n'importe quoi avec la mmoire. L'ASM n'a pas de limite et de scurit. Autant il peut tre utile, autant il peut dtruire ;)
Page 12
Les programmes faits en ASM sont plus petits, plus rapides et beaucoup plus efficaces que ceux fait avec des compilateurs, pourvu quil soit bien crit. Une des raisons de cette rapidit d'excution rside dans le compilateur. En fait, quand on code de quoi en C++, le compilateur doit convertir toutes les instructions en assembleurs, puis par la suite le convertir en langage machine tandis que si on code en ASM, le compilateur a juste besoin de le convertir en langage machine. Jusque l a change rien puisque les deux finissent en langage machine mais les compilateurs de C++, quand ils convertissent des trucs en assembleur, ils rajoutent pleins d'instructions inutiles au fonctionnement de base du programme (c'est comme faire un document html avec un diteur html). Tout le code qui rajoute va ralentir l'excution du programme.
C'est le seul langage permettant de modifier un programme compil dont on na pas les sources (utiles pour le Reverse Engineering entre autres). On peut l'insrer dans des langages de plus haut niveau pour les parties ncessitant d'tre optimiser, d'ailleurs bon nombre de langages de programmation permettent, afin de combler leurs lacunes (vitesse d'excution, accs aux priphriques, etc.), d'appeler des routines crites en assembleur.
Vous voulez apprendre quelque chose de nouveau, que vous allez trouver du fun le faire et lapplique et que vous nallez jamais le dplorer Et, cerise sur le gteau, le fait que l'ASM est trs complique n'est pas vraiment vrai.
L'assembleur se rvle tre un langage bien part, son apprentissage poursuit double objectif, dune part avoir une comprhension plus profonde de la faon dont fonctionne lordinateur, dautre part vous donnez des atouts considrables pour la comprhension et la matrise de tous les autres langages de programmation.
Que programmer en Assembleur ? Il est important de savoir ou et quand il faut utiliser l'ASM afin d'avoir un programme le plus performant tout en conservant des temps de dveloppement les plus courts possibles, lASM pourra vous tre utile dans plusieurs cas : Tout ce qui doit tre optimis au niveau de la taille, par exemple pour programmer un virus... Lorsque la vitesse dexcution est un facteur critique et que la moindre microseconde est prcieuse, ou ne peut pas tre fait avec autre chose que de l'assembleur, par exemple un driver de disque dur, un secteur de boot, ou une routine d'affichage de polygones/triangles en 3D...
Page 13
Bref, lassembleur est au programmeur ce que la cl de 12 est au mcano, le micro au chanteur, la plume l'crivain, ce que le sens de la chute tait Pierre Desproges ^^
Chapitre 1 : Notions de base Vu que lassembleur est qualifi comme tant le langage de programmation le plus bas niveau, il dpend donc fortement du type de processeur. Ainsi il n'existe pas un langage assembleur, mais un langage assembleur par type de processeur. Il est donc primordial davoir un minimum de connaissances techniques. Nous verrons ensemble certains points essentiels la bonne comprhension de la suite dinformations dveloppes dans ce guide savoir les termes techniques, les conventions, les bases numrales, les diffrents types de reprsentations, la mmoire et le microprocesseur. Cest l en effet que se trouvent les principales difficults pour le dbutant. Ne soyez pas rebut par labstraction des concepts prsents dans les premiers paragraphes : il est normal que durant la lecture, beaucoup de choses ne soient pas claires travers vos esprits. Tout vous semblera beaucoup plus simple quand nous passerons la pratique dans le langage assembleur. Ces informations permettront de rafrachir ou denrichir vos connaissances dans ce domaine.
Les systmes de numration Nous allons aborder un aspect trs important de la programmation en assembleur : le systme de numration. En informatique et en lectronique numrique, on emploie plusieurs formes de numration. Les quatres bases les plus employes sont les suivantes : binaire, octale, dcimale, hexadcimale. Voyons en dtail ces diffrentes bases. Dcimale Depuis la nuit des temps, l'homme a eu besoin de compter et de calculer. Selon les civilisations, divers systmes de numration on t mis en place puis abandonns. A l'heure actuelle, nous utilisons le systme de numration dcimal. Ce systme s'est impos en Europe partir du 10me sicle. Aujourd'hui le systme dcimal est quasiment universel. Lide de ce systme rside dans le fait que nous possdons dix doigts, lcriture dcimale ncessite donc lexistence de 10 chiffres qui sont 0, 1, 2, 3, 4, 5, 6, 7, 8, et 9.Lorsque nous crivons un nombre en mettant certains de ces chiffres les uns derrire les autres, lordre dans lequel nous mettons les chiffres est capital. Ainsi,
Page 14
par exemple, 4678 nest pas du tout le mme nombre que 8647. Et pourquoi ? Quelle opration, quel dcodage mental effectuons nous lorsque nous lisons une suite de chiffres reprsentant un nombre ? Le problme est que nous sommes tellement habitus faire ce dcodage de faon instinctive que gnralement nous nen connaissons plus les rgles. Mais ce nest pas trs compliqu de les reconstituer. Considrons par exemple le nombre 4678. Il est compos des chiffres des milliers (4), des centaines (6), des dizaines (7), et des units (8). On peut donc crire : 4687 = 4000 + 600 + 80 + 7
Ou bien encore : 4687 = 4 1000 + 6 100 + 8 10 + 7
Dune manire lgrement diffrente, mme si cela parat un peu bbte : 4687 = (4 1000) + (6 100) + (8 10) + 7
Arriv ce stade de la comptition, les matheux notent la ligne ci-dessus laide du symbole de puissance. Cela donne : 4687 = (4 103) + (6 x 102) + (8 x 101) + (7 x 100)
En rappel, tout nombre lev la puissance 0 est gal 1. Et voil, nous y sommes. Un nombre peut donc tre dcompos sous la forme de la somme de chacun des chiffres qui le composent, multiplis par la dimension de la base l'exposant de leur rang. Cette mthode n'est pas valable uniquement pour les nombres dcimaux. Binaire Un ordinateur n'ayant pas de doigts, compter en base dcimale ne lui est pas particulirement adapt. La base 2, plus connue sous le nom de la base binaire, l'est par contre beaucoup plus. Pour des raisons technologiques, lordinateur ne peut traiter quune information code sous forme binaire. Le courant lectrique passe ou ne passe pas, quon peut interprter en 0 ou 1. Dans la ralit physique il ny a pas de 0 de 1 qui se balade au cur de lordinateur. Le choix du 0 et de 1 est une pure convention, une image commode, que lon utilise pour parler de toute information binaire, et on aurait pu choisir nimporte quelle paire de symboles leur place, quelque chose qui ne peut avoir que de tats : par exemple, ouvert ou ferme, vrai ou faux, militaire ou civil, libre ou occup
Page 15
En base 2, tout nombre scrit laide des deux chiffres 0 et 1, appels bits (BInary digiT). C'est la plus petite unit d'information manipulable par une machine numrique. Or un bit n'est pas suffisant pour coder toutes les informations que l'on souhaitera manipuler. On va donc employer des groupements de plusieurs bits. Un groupe de 4 bits sappelle un quartet (Nibble en anglais). Un groupe de 6 bits sappelle un hexet. Un groupe de 8 bits sappelle un octet (Byte). Un groupe de 16 bits, soit deux octets, est appel un mot (Word). Un groupe de 32 bits, soit deux mots, est appel un double mot (Dword). Un groupe de 64 bits, soit deux doubles mots, est appel un (Qword).
Notez l'utilisation d'un B majuscule pour diffrencier Byte et bit.

Il existe des units de manipulation pour les trs grandes valeurs. Mme si elles ne sont pas employes par les micro-ordinateurs actuels, il est bon den connatre lexistence. Un kilo-octet (Ko) Un Mgaoctet (Mo) Un Gigaoctet (Go) Un Traoctet (To) = 1000 octets. = 1000 Ko = 1000000 octets. = 1000 Mo = 1000000000 octets. = 1000 Go = 1000000000000 octets.
Les bits sont gnralement regroups par 4 ou 8 bits. Dans la reprsentation binaire, on distingue les deux bits dextrmit dun nombre : Le bit de poids fort (Most Significant Bit, ou MSB) est le bit, dans une reprsentation binaire donne, ayant la plus grande valeur, celui le plus gauche. Exactement comme dans le nombre 189, c'est le chiffre le plus gauche qui le plus de poids, la valeur la plus forte. Le bit de poids faible (Least Significant Bit, ou LSB) est pour un nombre binaire le bit ayant dans une reprsentation donne la moindre valeur, celui le plus droite. Exactement comme dans le nombre 189, c'est le chiffre le plus droite qui le moins de poids, la valeur la plus faible. De mme, si lon dcoupe un nombre en deux, le premier paquet gauche est appel paquet de poids faible, le second paquet droite est appel paquet de poids fort. Ainsi un mot est compos de 2 octets : 1 octet de poids fort (Least Significant Byte).
Page 16
1 octet de poids faible (Most Significant Byte).
Si on fait un schma de ce quon vient de dire, on se retrouve avec ce qui suit :
10100101011010110101001000010101
M.S.Bit l.S.B
Les oprations arithmtiques simples telles que l'addition, la soustraction, la division et la multiplication sont facile effectuer en binaire.
Octale
Compter en octal, cest comme compter en dcimal, si on nutilise pas ses pouces - Tom Lehrer.
Comme vous le devinez srement, tous comme on peut dire que le binaire constitue un systme de codage en base 2, le dcimal un systme de base 10, vous laurez compris loctal est un systme de base 8. Ce systme utilise 8 symboles : 0, 1, 2, 3, 4, 5, 6, 7. Il nest plus gure employ aujourdhui, puisquil servait au codage des nombres dans les ordinateurs de premire gnration. Le systme octal a cd la place au systme hexadcimal. Etant donne que ce systme de numration nest plus vraiment employ, on ne sattardera pas davantage sur le sujet !
Hexadcimale La notation hexadcimale consiste compter non pas en base 2, 8, ou 10, mais en base 16. Cela ncessite d'avoir 16 chiffres. En dcimale vous comptez comme a : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, Et bien en hexadcimale on compte de cette manire : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, 10, 11, 12, Pour les dix premiers, on na t pas cherch bien loin : on a recycl les dix chiffres de la base dcimale, l il nous manque encore 6 chiffres, plutt quinventer de nouveaux symboles, on a alors convenu de les reprsenter par les premiers lettres de lalphabet. Ainsi par convention, A vaut 10, B vaut 11 et ainsi de suite jusqu F qui vaut 15.
Page 17
La raison pour laquelle l'hexa est utile est que la conversion entre l'hexa et le binaire est trs simple. Avec lavancement de la technologie, les nombres binaires sont devenus de plus en plus longs et rapidement incomprhensibles. Le systme hexadcimal est venu pour freiner l'accroissement en longueur des nombres binaires, il fournit une faon beaucoup plus compacte pour reprsenter le binaire, vous le voyez lhexadcimal comporte de nombreux avantages, on peut reprsenter 16 valeurs avec seulement un chiffre, alors quil en faut deux pour la dcimal, et quatre pour le binaire. Voyons voir cela de plus prs, avec 4 bits, nous pouvons coder 2 2 2 2 = 16 nombres diffrents. En base seize, 16 nombres diffrents se reprsentent avec un seul chiffre, de mme quen base 10, dix nombres se reprsentent avec un seul chiffre. Afin d'viter tout risque d'erreur entre bases, il est recommand d'crire un : "b" la fin d'un nombre binaire. "d" la fin d'un nombre dcimal (base par dfaut). "o" la fin d'un nombre octal. "h" la fin d'un nombre hexadcimal, toujours en minuscules, afin de ne pas confondre avec les "chiffres" hexadcimaux B et D. Par exemple : 11011b = 27d = 33o =1Bh Et enfin, la numration binaire, comme les autres systmes de numration, noblige pas la reprsentation des valeurs nulles ou inutiles, par exemple : Le nombre 220d = 11011100b est reprsentable sur 8 bits. Le nombre 16d = 00010000b est reprsentable sur 5 bits, ce qui donne rellement en omettant les chiffres zro inutiles 10000b. Le tableur ci-dessous montre lquivalence de reprsentation de nombre allant de 0 17 : Dcimal 0 1 2 3 4 5 6 Binaire 0000 0001 0010 0011 0100 0101 0110 Octale 0 1 2 3 4 5 6 Hexadcimal 0 1 2 3 4 5 6
Page 18
7 8 9 10 11 12 13 14 15 16 17 Les conversions entre bases numrales
0111 1000 1001 1010 1011 1100 1101 1110 1111 10000 10001
7 10 11 12 13 14 15 16 17 20 21
7 8 9 A B C D E F 10 11
Il est indispensable de savoir faire ce genre de conversion pour tre capable de se dbrouiller avec un simple crayon pointe de graphite et une feuille de papier (on na pas toujours sous la main une calculatrice quipe de ce genre de fonction)
Dcimale Binaire Prenons un nombre au hasard : 13d = 1101b. Bain, comment le 13 devient t'il 1101? Et bien c'est un petit peu comme si l'ordinateur rangeait treize boules dans une boite, une boite avec des colonnes, dans la premire colonne, en peut mettre qu'une seule boule, dans la deuxime : deux boules, dans la troisime : 4 boules, dans la quatrime : 8 boules. |______||_______||_______||_______|
Page 19
Attention l'ordinateur commence toujours par la plus grande colonnes et il ne fait que des colonnes pleines. Chaque fois qu'on a une colonne pleine c'est un 1. Chaque fois qu'on a une colonne vide c'est un 0.
Voyons ce que ca donne avec 13 boules : La colonne de 8 pas de problme, on peut la remplir, ca donne un 1, il nous reste cinq boules. La colonne de 4 on peut la remplir, c'est un 1, il nous reste une boule. La colonne de 2 on ne peut pas la remplir, c'est un 0. La colonne de 1 on peut la remplir c'est un 1. |___1___||___1___||___0___||___1___|
Donc, le nombre 13d correspond linformation binaire 1101b. Jusqu prsent, nous avons vu diffrents moyens de codage de nombres. Mais il est ncessaire de savoir galement comment coder des caractres alphanumriques. Par exemple lors de leur entr partir dun clavier. La mmoire de l'ordinateur conserve toutes les donnes sous forme numrique. Il n'existe pas de mthode pour stocker directement les caractres. Dans les annes 60, le code ASCII (American Standard Code for Information Interchange), qui est actuellement le plus connue et le plus largement compatible, est adopt comme standard, chaque caractre possde donc son quivalent en code numrique, par exemple la lettre M correspond au nombre 77d. Un nouveau code, plus complet, qui supplante l'ASCII est l'Unicode. Une des diffrences cls entre les deux codes est que l'ASCII utilise un octet pour encoder un caractre alors que l'Unicode en utilise deux (ou un mot). Par exemple, l'ASCII fait correspondre l'octet 41h (65d) au caractre majuscule A; l'Unicode y fait correspondre le mot 0041h. Comme l'ASCII n'utilise qu'un octet, il est limit 256 caractres diffrents au maximum. L'Unicode tend les valeurs ASCII des mots et permet de reprsenter beaucoup plus de caractres. C'est important afin de reprsenter les caractres de tous les langages du monde. Jai inclus la liste des diffrents codes ASCII ainsi que leur signification en annexe Mais comment tu fais pour faire 77 !! Regarde bien ton boulier, il n'a que (8 + 4 + 2 + 1) a fait 15. Bien cette fois ci, il suffit d'agrandir le boulier et voil: |______||______||______||______||______||______||______||______|
Page 20
128

64
32
16
Avec 77 boules, on ne peut pas remplir la colonne de 128, c'est un 0. On rempli en revanche la colonne de 64, cest un 1, il nous reste 13 boules. Pas assez pour remplir la colonne de 32, c'est un 0. Pas assez non plus pour rempli la colonne de 16, c'est un 0. Assez pour remplir la colonne de 8, c'est un 1, il nous reste deux boules. Je remplis la colonne de 4, l cest un 1. Pas assez pour remplir la colonne de 2, c'est un 0. Et comme jai plus quune seule boule, je remplis la dernire colonne, cest un 1. |___0___||___1___||___0___||___0___||___1___||___1___||___0___||___1___|
128
64
32
16
Donc, la lettre M correspond linformation binaire 01001101b. Il existe une autre mthode classique pour transformer un nombre du systme dcimale dans un autre systme, par divisions successives. La mthode de dcomposition par divisions successives consiste diviser le nombre plusieurs fois (si ncessaire) dans la base choisie jusqu' obtenir un quotient nul. Tant quil sagit dune conversion dcimale binaire, on divise par 2. Les restes successifs des divisions, pris dans leur ordre inverse, forment le nombre dsir. Reprenons le mme exemple. La division entire de 77 par 2 donnes : 77 | _2_ _ | 38 1 | 0 |_2_ _ | 19 | 1 | 1 |_2_ _ | 9 | 0 | 0 | 1 |_2_ _ | 4 |_2_ _ | 2 | |_2_ _ 1
Attention au sens de lecture
Page 21
Lcriture binaire de 77d est donc : 01001101b.
Binaire Dcimale Une fois que le systme binaire est bien compris, il est facile de transposer ses principes pour comprendre le systme binaire. Je rappelle, pour trouver la valeur dun nombre binaire, il faut, linstar des bits dcimaux, multiplier la valeur du bit par la valeur de 2 expos par la position du bit moins un. Cependant, dans ce cas-ci, puisque le bit peut seulement tre 1 ou 0, le calcul revient plus une dcision dinclure la valeur ou non dans le nombre binaire qu une multiplication. Ainsi, pour trouver la valeur dun nombre binaire vous pouvez utiliser le tableau suivant :
-----------------------------------------------------------------0 27 1 26 0 25 0 24 1 23 1 22 0 21 1 20 ---------------------------------------------------------------------------------------------------------------------------------Do 01001101b correspond : (0 27) + (1 x 26) + (0 x 25) + (0 x 24) + (1 x 23) + (1 x 22) + (0 x 21) + (0 x 20) = 77d. En suivant les principes noncs dans la conversion binaire. Cependant il ne s'agit plus, de puissances de 2 mais de puissances de 16 puisque la base est 16.
Binaire Hexadcimale Pour convertir un nombre en hexadcimale, il yen a deux mthodes lune consiste faire un grand dtour, en repassant par la base dcimale. Lautre mthode consiste faire le voyage direct du binaire vers lhexadcimale. La premire mthode :
Page 22
Prenons un octet au hasard : 1011 1101. A partir de ce quon vient de voir, notre 1011 1101 deviendront : (1 27) + (0 x 26) + (1 x 25) + (1 x 24) + (1 x 23) + (1 x 22) + (0 x 21) + (1 x 20) = 189d. De l, il faut repartir vers la base hexadcimale. Dcimale hexadcimale On utilise la mthode des divisions successives, mme principe que pour le systme binaire, sauf que lon divise par 16. On note les restes des divisions successives puis on lit ces restes en remontant. Exemple : 189 | _16_ | 11 13 | 11 |_16_ | 0 |
On y est le nombre scrit donc en hexadcimal : BDh
Hexadcimale Dcimale : Inversement il est ais de passer d'un nombre en hexadcimal un nombre dcimal par multiplications successives, en suivant les principes noncs dans la conversion binaire. Cependant il ne s'agit plus, de puissances de 2 mais de puissances de 16 puisque la base est 16. Exemple : BDh = (11 x 161) + (13 x 160) = 176 + 13 = 189d La deuxime mthode :
Plus rapide consiste dcouper le nombre binaire en quartets, partir de la droite, puis remplacer chaque quartet par le symbole hexadcimal correspondant Dans l'exemple prcdent, on peut remarquer que 1011 1101 en binaire, nous conduit B D en hexadcimal.
Page 23
1011, cest 8+2+1, donc 11. 1101, cest 8+4+1, donc 13. Le nombre scrit donc en hexadcimal : BD. Cest la mme conclusion quavec la premire mthode.
Hexadcimale Binaire Le passage de l'hexadcimal en binaire peut se faire de la manire inverse, en convertissant les chiffres qui composent le nombre hexadcimal en leur quivalent binaire. Notez que les 0 de tte des 4 bits sont importants ! Si Exemple : BDh = B 1011 D 1101 On trouve donc que BDh = 10111101b.
Ya til des nombres ngatifs en binaire ? Bien sr que oui, jusqu prsent nous avons parl de mots binaires sans en spcifier le signe. Un nombre tel qu'on appris l'crire est appel un nombre non sign (unsigned en anglais), il est toujours positif. Au contraire, maintenant nous allons apprendre crire des nombres qui peuvent reprsenter des valeurs soit positifs, soit ngatifs. On dira qu'ils sont signs (signed). Un nombre sign nest donc pas forcment ngatif. Chaque bit dun octet peut occuper deux tats, il ya donc dans un octet : 2 2 2 2 2 2 2 2 = 28 = 256 possibilits. Donc il est possible de coder des nombres allant de 00000000 11111111 en binaire, soit 00 FF en hexadcimal et 0 255 en dcimal. Considrons lopration 0 1 = 1 en dcimal, elle consiste retrancher 1 de 0, et tentons de la raliser en binaire. 0 1 = -----= -1 0 0 1 0 0 1 0 0 1 0 1 0 0 0 1 0 0 1 0 0 1 0 1 1
-----------------------------------------------------------------------------------------
Donc 1d sera reprsent par FFh. Recommenons et soustrayons 1 -1 : 1 1 1 1 1 1 1 1 1
Page 24
1 =
0 1
0 1
0 1
0 1
0 1
0 1
0 1
1 0
-----= -2
-----------------------------------------------------------------------------------------
So, -2d sera reprsent par FEh. Ceci dit cette mthode de dtermination de la reprsentation binaire d'un nombre ngatif n'est pas trs commode, c'est pourquoi nous allons introduire la notion de notation en complment 2. La procdure est la suivante : Si le nombre est positif, conversion identique. Si le nombre est ngatif: 1. On convertit d'abord sa valeur absolue en binaire.
2. On inverse tous les bits du nombre: les 0 deviennent des 1, les 1 deviennent des 0 (complment 1). 3. On ajoute 1 au rsultat. Par exemple, pour reprsenter -2 sur 8 bits: 2 s'crit 00000010b -2 s'crit donc 11111101b + 1b = 11111110b.
Le rsultat trouv est bien le mme que prcdemment. Nous pouvons vrifier que l'opration +2 - 2 donne bien zro sur 8 bits. Le 1 situ gauche nest pas pris en compte. Par cette mthode il est donc possible de coder les nombre dcimaux compris entre -128 et 127. Le bit du poids fort de chaque octet est gal : 0 si le nombre est positif. 1 si le nombre est ngatif.
Notons que cette notation en complment deux n'est pas obligatoire. C'est au programmeur de dcider si les nombres qu'il utilise sont compris entre 0 et 256 ou bien entre -128 et + 127.
Oprations Arithmtiques
Page 25
On
peut
tout
comme
avec
le
dcimal
effectuer
des
oprations
standards
tout
comme
l'addition, la soustraction la division et la multiplication. Laddition Un rappel srement inutile mais qui clarifie des choses... Quand vous faites une addition en dcimal, vous faites la somme des chiffres se trouvant dans une mme colonne : Si la somme est infrieure 10, alors vous posez le rsultat obtenu et passez la colonne suivante. Si la somme est suprieure 10, alors vous posez le chiffre des units et gardez en retenue le chiffre des dizaines. Si vous faites la somme de 2 nombres, alors la retenue ne pourra tre suprieure 1. Le principe est exactement le mme en binaire, on commence additionner les bits de poids faible, les bits de droite, puis on a des retenues, lorsque la somme de deux bits poids dpasse la valeur de lunit la plus grande (dans le ca binaire : 1), cette retenu est report de poids plus fort suivant... En suivant ce principe, on obtient en binaire la table daddition suivante : ___________________________________________________ Rsultat 0+0= 0+1 = 1+0 = 1+1 = 0 1 1 0 Report 0 0 0 1 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------__________________________________________________
Pour illustrer ce principe, effectuons par exemple les oprations suivantes :
11 1 0 0 1
1 0
1 1 1 1
Page 26
0 1
1 1
0 1
1 0
+ 1
1 0
0 0
0 0
1 0
-------------------------------------
-------------------------------------
De mme en hexadcimal, il suffit de procder comme dans le systme dcimale, ainsi nous obtenons : A + = 3 D 2 C E Ah = 10d Ch = 12d
----------------------
Dsol cet exemple ne comporte pas de retenues, les nombres obtenus tant plus grand que 16 nous additionnons 4 et nous effectuons un report, en voici un qui en comporte:
2 + 5 1 = 7
F 3
Fh = 15d
------------------------18 4 ------------------------= = 8 8 22 2 -------------------------
Ainsi 2Fh + 53h = 82h. Nous pouvons constater quune table daddition en hexadcimal ou une calculatrice avec la fonction BIN, DEC, OCT, ET HEX se relve un outil prcieux. La soustraction Pour effectuer une soustraction en binaire, nous procdons de la mme faon que pour une soustraction en dcimale, il ya quatre cas possibles : _______________________________________________ Rsultat Emprunt
Page 27
--------------------------------------------------------------00 = 0-1 = 1-0 = 1-1 = 0 0 1 1 0 0 1 0 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------_______________________________________________ Voyons ce que a donne :
1 1 0 0 0 1 0 0 1 0 0 1 1 1 1 0
1 0 0 0 1 0 0
1 0 1 1
-------------------------------------
-------------------------------------
En hexadcimal, a marche comme en dcimal. La seule difficult provient de ce que l'on n'apprend pas la table d'addition en hexadcimal. B+F=1A par exemple. Il faut donc rflchir un peu plus qu'en dcimal F A 5 9 2 7
--------------------
Vous avez vu ? Ce nest pas si dur ! On pourrait, de la mme faon, illustrer le fonctionnement d'autres oprations arithmtiques en binaire, mais l ce n'est pas notre objectif. Cest tout ce qu'il faut retenir jusquici.
Page 28
Astuce Dornavant, ne vous vous souciez pas de faire ces calculs la main. La solution est beaucoup plus simple que cela. Procurez vous de votre calculatrice Windows. Pour ce faire, le moyen le plus rapide est de cliquer sur touche "Windows" + R, tapez "calc" et cliquer sur OK. Un raccourci est aussi disponible, pour les amants de la souris, dans le menu tous les programmes, dans le sous-menu accessoires. Une fois que vous avez dmarr la calculatrice, rassurez-vous que vous soyez en mode scientifique,
(Affichage/Scientifique). Vous pouvez choisir le systme numrique laide des 4 boutons radios
encercls (Hex = Hexadcimale, Dc = dcimal, Oct = Octale et Bin pour binaire, ensuite, cliquez sur le systme numral dans lequel vous voulez avoir la conversion. Cela fait dj une bonne base pour commencer, vous avez appris les systmes de numration. Vous devriez tre en mesure deffectuer de simples conversions facilement. Chapitre 2 : Organisation de l'Ordinateur Et c'est parti pour l'assembleur, je rassemble mon cerveau et prend mon courage deux pattes... en effet, il va m'en falloir, car aprs les explications de bases, assez facile, et que vous connaissiez sans doute dj, on va s'attaquer un gros morceau trs important dans la programmation en assembleur, puisqu'il s'agit de la gestion de la mmoire. Il est vital de comprendre comment elle est organise, et comment on y accde efficacement. D'ou le titre. Nous y voil. Encore un chapitre barbant... Donc comme je l'ai dit plus haut, ce chapitre est extrmement important. Car aprs a, on entrera de plein pied dans la programmation en apprenant des instructions en plus grosse quantit, puis dans les chapitres suivants, nous aborderont la structure des donnes. Donc je le souligne bien, il faut comprendre ce chapitre. Pour dcrire brivement ce chapitre, je peux dj vous dire qu'il traitera de l'organisation de la mmoire, de la faon dont le processeur communique avec, les diffrents registres des processeurs Intel de la famille 80x86, les modes d'adressage de ces processeurs, ensuite nous expliquerons le fonctionnement des registres et des drapeaux ainsi que la pile. Enfin, nous verrons les premires instructions d'assembleur, lies donc la gestion de la mmoire.
Un microprocesseur, en deux mots Sans entrer dans les dtails qui seront vus en cours, nous prsentons le minimum savoir sur ce quest un microprocesseur.
Page 29
Le microprocesseur, not CPU (Central Processing Unit), est un lment indispensable dans un ordinateur. Il s'agit d'un lment semi-conducteur au silicium dont la fabrication ncessite une prcision extrme. En effet, le microprocesseur regroupe un certain nombre de transistors lmentaires interconnects, caractris par une trs grande intgration et dot des facults fonctionnelles dinterprtation et dexcution des instructions dun programme. Le microprocesseur nest pas uniquement utilis au sein des PC. De plus en plus les objets qui nous entourent sont truffs de microprocesseurs, de la voiture au tlphone portable en passant par la chaudire et la tlvision. Un microprocesseur constitue le cur de tout ordinateur: il excute les instructions qui composent les programmes que nous lui demandons dexcuter. Les instructions sont stockes en mmoire (en dehors du microprocesseur). Ces instructions (dont lensemble compose le langage assembleur) sont trs simples mais nen permettent pas moins, en les combinant, de raliser nimporte quelle opration programmable. Pour excuter un programme, le processeur lit les instructions en mmoire, une par une. Il connat tout instant ladresse (lendroit dans la mmoire) laquelle se trouve la prochaine instruction excuter car il mmorise cette adresse dans son compteur ordinal. Avant de nous intresser plus particulirement larchitecture interne dun microprocesseur, il convient de connatre lvolution impressionnante de ces composants.
Historique Le concept de microprocesseur a t cr par la Socit Intel. Cette Socit, cre en 1968, tait spcialise dans la conception et la fabrication de puces mmoire. la demande de deux de ses clients fabricants de calculatrices et de terminaux Intel tudia une unit de calcul implmente sur une seule puce. Ceci donna naissance, en 1971, au premier microprocesseur du monde, le 4004, qui tait une unit de calcul 4 bits fonctionnant 108 kHz. Il rsultait de lintgration denviron 2300 transistors. A partir de cette date, un rythme trs rapide dvolution sest install. De nombreux autres modles sont apparus, de plus en plus puissants et de plus en plus complexes. Ce rythme dvolution sest maintenu sans flchir jusqu aujourdhui. Ces volutions concernent les techniques dintgrations des nombres de transistors et la frquence dhorloge des processeurs. Il y a galement dautres amliorations, comme la largeur de bus mmoire, la taille des registres ou la taille de la mmoire cache. Dans le mme intervalle de temps, leur puissance de traitement est passe de 60 000 instructions excutes par seconde par l'Intel 4004 plusieurs milliards par les machines actuelles les plus puissants. Lhistoire des
Page 30
microprocesseurs sur les trente dernires annes est certainement la plus formidable volution technologique de l'histoire humaine, tant en dure qu'en ampleur. Aujourd'hui, le multimdia puis le 3D et le temps rel. Demain, le monde virtuel ! Ce rythme d'volution effrn est appel loi de Moore (Gordon E. Moore, du non du prsident de la compagnie Intel qui l'a formul dans les annes 70). Il prvoyait que les performances des processeurs (par extension le nombre de transistors intgrs sur silicium) doubleraient tous les 12 mois. Cette loi a t rvise en 1975, portant le nombre de mois 18. La loi de Moore se vrifie encore aujourd'hui. Moore estime que cette volution se poursuivra jusquen 2017, date laquelle elle devrait rencontrer des contraintes lies la physique des atomes. Le tableau si dessous recense lvolution de la gamme des processeurs compatibles Intel x86, avec les dates des premires versions de chaque modle.
Date
Nom
Nombre de transistors
Finesse de gravure (m)
Frquence de l'horloge
Largeur des donnes
MIPS
1971
4004
2 300
108 kHz
4 bits/4 bits bus
1974
8080
6 000
2 MHz
8 bits/8 bits bus
0,64
1979
8086 - 8088
29 000
5 MHz
16 bits/8 bits bus
0,33
1982
80286
134 000
1,5
6 MHz
16 /16 bits bus
Page 31
1985
80386
275 000
1,5
16 40 MHz
32 bits/32 bits bus
1989
80486
1 200 000
25 100 MHz
32 bits/32 bits bus
20
1993
Pentium
3 100 000
0,8 0.28
60 233 MHz
32 bits/64 bits bus
100
1997
Pentium II
7 500 000
0,35 0.25
233 450 MHz
32 bits/64 bits bus
300
1999
Pentium III
9 500 000
0,25 0.13
450 1400 MHz
32 bits/64 bits bus
510
2000
Pentium 4
42 000 000
0,18 0.065
1,3 3.8 GHz
32 bits/64 bits bus
1 700
2004
Pentium 4D Prescott
125 000 000
0,09 0.065
2.66 3.6 GHz
32 bits/64 bits bus
9 000
2006
Core 2 Duo
291 000 000
0,065
2,4 GHz (E6600)
64 bits/64 bits bus
22 000
2007
Core 2 Quad
2*291 000 000
0,065
3 GHz (Q6850)
64 bits/64 bits 2*22 000 bus (?)
Page 32
2008
Core 2 Duo (Penryn)
410 000 000
0,045
3,16 GHz (E8500)
64 bits/64 bits bus
~24 200
2008
Core 2 Quad (Penryn)
2*410 000 000
0,045
3,2 GHz (QX9770)
64 bits/64 bits bus
~2*24 200
Cette miniaturisation a permis: D'augmenter les vitesses de fonctionnement des processeurs, car les distances entre les composants sont rduites. De rduire les cots, car un seul circuit en remplace plusieurs. De crer des ordinateurs bien plus petits : les micro-ordinateurs.
Comme dans tout circuit intgr la technologie de fabrication impose au microprocesseur des caractristiques : Le jeu d'instructions quil peut excuter. Tout microprocesseur contient en lui-mme un jeu d'instructions. Ces instructions, trs basiques, se rsument une tche simple, par exemple : Mettre telle valeur dans la mmoire. Ou additionner telle valeur avec telle autre valeur et mettre le rsultat dans la mmoire. Comparer deux nombres pour dterminer sils sont gaux, comparer deux nombres pour dterminer lequel est le plus grand, multiplier deux nombres... La complexit de son architecture. Cette complexit se mesure par le nombre de transistors contenus dans le microprocesseur. Plus le microprocesseur contiendra de transistors, plus il pourra effectuer des oprations complexes, et/ou traiter des chiffres des grande taille. Le nombre de bits que le processeur peut traiter ensemble, autrement la longueur des donnes que peut manipuler un microprocesseur. Les premiers microprocesseurs ne pouvaient traiter plus de 4 bits d'un coup. Ils devaient donc excuter plusieurs instructions pour additionner des nombres de 32 ou 64 bits. Les microprocesseurs actuels (en 2007) peuvent traiter des nombres sur 64 bits ensemble. Le nombre de bits est en rapport direct avec la capacit traiter de grands nombres rapidement, ou des nombres d'une grande prcision (nombres de dcimales significatives).
Page 33
La vitesse de lhorloge. Le rle de lhorloge est de cadencer le rythme du travail du microprocesseur. L'horloge tourne une frquence fixe (appele vitesse d'horloge). Lorsque vous achetez un ordinateur 1,6GHz, 1,6GHz est la frquence de cette horloge. L'horloge ne dcompte pas les minutes et les secondes. Elle bat simplement un rythme constant. Les composants lectroniques du processeur utilisent les pulsations pour effectuer leurs oprations correctement comme le battement d'un mtronome aide jouer de la musique un rythme correct. Le nombre de battements (ou, comme on les appelle couramment cycles) que requiert une instruction dpend du modle et de la gnration du processeur. Le nombre de cycles dpend de l'instruction. Plus la vitesse de lhorloge naugmente, plus le microprocesseur complte de calculs en une seconde.
Notations x86 ou i86 : est la dnomination de la famille de microprocesseurs compatibles avec le jeu d'instructions de l'Intel 8086. Les diffrents constructeurs de microprocesseurs pour PC se doivent de maintenir une compatibilit ascendante afin que les anciens logiciels fonctionnent sur les nouveaux microprocesseurs. L'architecture de la srie x86 partir du Pentium a t nomme IA-32 par Intel. IA-32 (Intel architecture 32 bits) ou i386 : dsigne l'architecture partir du Intel 80386, 32 bits, qui a enfin permis de sortir du mode rel correctement, et de faire un bon multitches sur les Intel. Et d'avoir un adressage mmoire de 4 Go. IA-64 (Intel Architecture 64 bits) dsigne larchitecture des nouvelles est une architecture de processeurs Intel destines remplacer les x86. Il s'agit d'une rupture totale avec la srie x86, le jeu d'instructions n'ayant plus rien voir, ni les lments de l'architecture du processeur. Le rsultat est quelque chose de globalement nettement plus simple, donc de bien plus rapide, en donnant un contrle plus fin au logiciel sur le matriel. Il faut savoir que les familles de processeur ce sont succds en ajoutant leurs lots d'amliorations, et pas uniquement en matire de rapidit. Voici les principaux processeurs x86: 8088/8086, 80188/80186, 80286, 80386, 80486, 80586/pentium. 8088, 8086: Ces processeurs, du point de vue de la programmation sont identiques. Ils taient les processeurs utiliss dans les tous premiers PC. Ils offrent plusieurs registres 16 bits : AX, BX, CX, DX, SI, DI, BP, SP, CS, DS, SS, ES, IP, FLAGS. Ils ne supportent que jusqu' 1Mo de mmoire et n'oprent qu'en mode rel. Dans ce mode, un programme peut accder n'importe quelle adresse mmoire,
Page 34
mme la mmoire des autres programmes ! Cela rend le dbogage et la scurit trs difficiles ! De plus, la mmoire du programme doit tre divise en segments. Chaque segment ne peut pas dpasser les 64Ko. 80286: Ce processeur tait utilis dans les PC de type AT. Il apporte quelques nouvelles instructions au langage machine de base des 8088/86. Cependant, sa principale nouvelle fonctionnalit est le mode protg 16 bits. Dans ce mode, il peut accder jusqu' 16Mo de mmoire et empcher les programmes d'accder la mmoire des uns et des autres. Cependant, les programmes sont toujours diviss en segments qui ne peuvent pas dpasser les 64Ko. 80386: Ce processeur a grandement amlior le 80286. Tout d'abord, il tend la plupart des registres 32 bits (EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, EIP) et ajoute deux nouveaux registres 16 bits : FS et GS. Il ajoute galement un nouveau mode protg 32 bits. Dans ce mode, il peut accder jusqu' 4Go de mmoire. Les programmes sont encore diviss en segments mais maintenant, chaque segment peut galement faire jusqu' 4Go ! 80486/Pentium/Pentium Pro: Ces membres de la famille 80x86 apportent trs peu de nouvelles fonctionnalits. Ils acclrent principalement l'excution des instructions. Le 80586, appel Pentium pour des raisons de protection commerciale, dispose d'un bus de donnes de 64 bits et est muni d'un dispositif de prvision des branchements. Il est constitu de 2 processeurs en pipe-line parallles lui permettant d'excuter deux instructions en mme temps. Son cadencement est envisag (en 1994) jusqu' 150 MHZ. Pentium MMX: Ce processeur ajoute les instructions MMX (MultiMedia eXentions) au Pentium. Ces instructions peuvent acclrer des oprations graphiques courantes. Pentium II: C'est un processeur Pentium Pro avec les instructions MMX (Le Pentium III est grossirement un Pentium II plus rapide). Pourquoi les diffrents microprocesseurs dIntel sont-ils alors compatibles entre eux ? Tout simplement parce que chaque fois que Intel sort un nouveau processeur, toutes les instructions des processeurs prcdents sont incluses. En fait, il ny a gnralement pas beaucoup de nouvelles instructions ajoutes. Ceci nous assure que les vieux programmes (ceux crits pour de plus vieux
Page 35
microprocesseurs compatibles) peuvent parfaitement rouler (fonctionner) sur les nouveaux processeurs. Par contre, les nouveaux programmes, sils emploient les nouvelles fonctions plus performantes des nouveaux microprocesseurs, ne pourront pas fonctionner sur les microprocesseurs plus anciens. Cest ce quon appelle la compatibilit ascendante. Les nouveaux PC sont compatibles avec les anciens, mais pas le contraire. Les nouveaux Macintosh sont compatibles avec les anciens, mais pas le contraire. Les PC ne sont pas compatibles avec les Macintosh. Le mode de fonctionnement des x86 Le 8086, 8088, 80186 et 80188 nont quun mode de fonctionnement, le mode rel : 1 Mo au maximum et ils sont monotches. A partir du 80286 et surtout du 80386, il y a eu trois modes de fonctionnement. En voici le dtail : Le mode rel : mode par dfaut du microprocesseur, celui dans lequel est le processeur au dmarrage, et dans lequel s'excute DOS. Il fournit les mmes fonctionnalits que le 8086. Cela a plusieurs consquences, dont lune est quil nest pas possible dadresser plus que 1 Mo mmoire. Le mode protg : exploit par Windows partir de la version 3.1. Il tire son nom de "protg" de ses nombreuses fonctions de protection. Le terme protection signifie ici "protection contre les bugs ou les programmes malveillants". Eh oui, en mode protg, les programmes sont soumis des rgles trs strictes, qui ne sont pas rellement astreignante pour des programmeurs normaux, mais qui sont terribles ds que le programme tente de sortir de l'espace qui lui est rserv. Pourquoi donc ? Le mode protg t conu pour permettre l'existence de systmes multitches stables. Imaginons qu'une des tches commette une "erreur de protection", le systme d'exploitation la ferme, et le systme de plante pas - du moins en thorie... Par exemple, il est n'est pas possible une tche de faire des E/S sur certains ports, donc de modifier anarchiquement l'tat du matriels, ce qui pourrait entraner un plantage - seul le systme d'exploitation est autoris le faire, mais il a pour mission de contrler scrupuleusement le processus... (Et l, on voit que Windows 95 a t fait lgrement la vavite...). Il n'est pas non plus possible de lire des portions de mmoires rservs d'autres programmes ou au systme d'exploitation, question de confidentialit et de scurit. Ce qui est trs apprciable, c'est que toutes les erreurs qui pourraient survenir dclenchent ce que l'on nomme une Exception, c'est dire une interruption dclenche par le processeur, intercepte par le systme d'exploitation, qui prend les mesures ncessaires (fermer l'application en question). Consquence immdiate : les plantages, c'est du pass !
Page 36
Le mode virtuel est un mode qui permet des programmes raliss pour le 8086 de tourner sur un systme multiutilisateur, comme sil y avait plusieurs processeurs dans le mme.
Organisation interne du microprocesseur Maintenant que nous savons ce qu'est un microprocesseur, penchons-nous sur son organisation intrieure. En effet, un nombre trs important de divers lments est compris dans la puce de silicium que vous avez pu observer ci-dessus. En fait, un microprocesseur x86 nest pas uniquement un bloc de n millions de transistors, mais bien un assemblage intelligent et fortement optimis de blocs de transistors nomms units. Chaque unit est ddie une tche prcise. On peut les regrouper en trois parties principales. Il s'agit de : l'UAL (Unit Arithmtique et Logique) ; de l'Unit de commande ; et du jeu de registres ;
L'unit arithmtique et logique est un lment particulirement important au cur du microprocesseur. L'unit arithmtique et logique est commande par l'unit de commande. Son rle et d'effectuer des oprations mathmatiques de base, comme des additions, des soustractions, des multiplications ou des divisions. L'unit arithmtique et logique est galement capable d'effectuer des oprations logiques, comme les fonctions NON, ET-Logique, OU-inclusif, OU-Exclusif, etc. Les lments que l'UAL doit traiter proviennent du jeu de registres. Le jeu de registre contient l'ensemble des registres du microprocesseur. On appelle registres des cellules mmoires qui sont loges non pas dans la mmoire RAM de l'ordinateur, mais directement sur le processeur lui mme dans le but de recevoir des informations spcifiques, notamment des adresses et des donnes stockes durant l'excution d'un programme. Il existe plusieurs types de registres, mais ils sont en nombre trs limite. Certains d'entre eux sont affects des oprations d'ordre gnral et sont accessibles au programmeur tout moment. Nous disons alors qu'il s'agit de registres gnraux. D'autres registres ont des rles bien plus spcifiques et ne peuvent pas servir un usage non spcialis. Enfin, d'autres registres sont invisibles et par consquent inaccessible au programmeur. Ces registres ne sont accessibles qu'au microprocesseur. Lorsque nous excutons un programme, l'UAL
Page 37
toujours accs ces registres. Nous verrons plus loin qu'il est possible d'affecter des valeurs notre guise aux registres gnraux. Les registres prsentent l'avantage de permettre un accs beaucoup plus rapide qu'un accs la RAM. Le microprocesseur et la mmoire RAM constituent en effet deux lments distincts d'un systme informatique et le processeur doit tout d'abord charg travers un canal toutes les donnes auxquelles il veut accder. Cela entrane naturellement un certain dlai qui peut tre vit en stockant les donnes directement dans le microprocesseur. C'est justement cela que servent les registres. Les instructions agissent sur des donnes qui sont situes soit en mmoire, soit dans des registres du processeur. Pour accder une donne en mmoire, il faut spcifier son adresse. Pour accder une donne dans un registre, il faut spcifier son nom (chaque registre possde un nom qui est une chane de caractres). On peut les regrouper en quatre catgories. Registres gnraux (ou de travail). Registres doffset (de dplacement, de pointeur, ou dindex). Registres de segment. Registres de flag (dtats, des indicateurs, dexceptions ou de drapeaux).
Si lon schmatise :
Page 38
Registres gnraux Chaque gnration tant un amalgame et une amlioration des prcdents, excepts pour les 8088, 8086, 80188, 80186, et 80286 pour lesquels le registre est identique. C'est pourquoi quand je parlerai de 8086, il sera en fait question de ces 5 processeurs. Le processeur 8086 original fournissait quatre registres gnraux de 16 bits: AX (Accumulateur) ; BX (Base) ; CX (Compteur) ; et DX (Donnes). donnes
Ils ne sont pas rservs un usage trs prcis, aussi les utilise-t-on pour manipuler des pour la plupart des oprations, mais ils ont tous une fonction principale qui les caractrisent.
diverses. Ce sont en quelque sorte des registres tout faire. Chacun de ces quatre registres peut servir
Le registre AX sert souvent de registre d'entre-sortie : on lui donne des paramtres avant d'appeler une fonction ou une procdure. Il est galement utilis pour de nombreuses oprations arithmtiques, telles que la multiplication ou la division de nombres entiers. Lorsque vous devez utiliser un registre pour une opration quelconque et que vous ne savez pas lequel utiliser, privilgiez celui-ci cest le plus optimis au niveau de la rapidit dexcution des oprations. Il est appel "accumulateur". Exemple :
Le registre BX peut servir de base. Il est utilis pour ladressage indirect, nous verrons plus tard ce que ce terme signifie. Le registre CX est utilis comme compteur dans les boucles. Par exemple, pour rpter 10 fois une instruction en assembleur, on peut mettre la valeur 10 dans CX, crire l'instruction prcde d'une tiquette qui reprsente son adresse en mmoire, puis faire un LOOP cette adresse. Lorsqu'il
Page 39
reconnat l'instruction LOOP, le processeur "sait" que le nombre d'itrations excuter se trouve dans CX. Il se contente alors de dcrmenter CX, de vrifier que CX est diffrent de 0 puis de faire un saut "jump" ltiquette mentionne. Si CX vaut 0, le processeur ne fait pas de saut et passe linstruction suivante. Exemple :
Chacun de ces registres peut tre dcompos en deux sous registres de 8 bits. Par exemple, le registre AX pouvait tre dcompos en AH et AL comme le montre la Figure si dessus. Le registre AH contient les 8 bits de poids fort de AX, et AL contient les 8 bits de poids faible. (H pour High et L pour Low). Au lancement des processeurs 80386 et plus rcents, tous ces registres ont t tendus 32 bits. Ainsi, le registre AX est devenu EAX (Extended AX). Pour la compatibilit ascendante, AX fait toujours rfrence au registre 16 bits et on utilise EAX pour faire rfrence au registre 32 bits. AX reprsente les 16 bit de poids faible de EAX tout comme AL reprsente les 8 bits de poids faible de AX (et de EAX). Il n'y a pas de moyen d'accder aux 16 bit de poids fort de EAX directement. Mais alors, pour travailler sur la partie haute des 32 bits, il faut employer le registre EAX ou faire une rotation des bits pour la ramener sur les 16 bits du bas accessibles via AX. Il est vident que ces quatre registres sont lis. Il lon modifie par exemple AH, cela changera AX, et par consquent EAX. Seuls AH et AL sont indpendant lun de lautre. Pour modifier la partie haute des 32 bits du registre EAX, il faut procder via le registre EAX. Par contre, pour modifier la partie basse des 32 bits, on peut procder laide du registre AX. Il est galement possible de modifier la partie haute du registre de 16 bits AX avec le registre AH, et la partie basse avec le registre AL. Il est intressant de travailler avec ces registres (AH et AL) pour la manipulation de caractres ou des donnes dont la taille ne dpasse pas un octet. Dans le tableau suivant, vous pouvez visualisez cette dcomposition : Registre(s) EAX Taille 32 bits
Page 40
AX AH AL
16 bits 8 bits chacun
Les autres registres tendus sont EBX, ECX, EDX, ESI et EDI. La plupart des autres registres sont galement tendus. BP devient EBP; SP devient ESP; IP devient EIP; et FLAGS devient EFLAGS.
Registres de segments Les registres 16 bits CS, DS, SS et ES sont des registres de segment. Ils indiquent quelle zone de la mmoire est utilise pour les diffrentes parties d'un programme. Contrairement aux registres gnraux, ces registres ne peuvent servir pour les oprations courantes : ils ont un rle trs prcis. On ne peut dailleurs pas les utiliser aussi facilement que AX ou BX, et une petite modification de lun deux peut suffire planter le systme. Eh oui ! CS pour segment de code, registre permettant de fixer ou de connaitre ladresse du dbut des instructions dun programme. DS pour segment de donnes, ce registre est ddi la localisation de vos donnes. SS pour segment de pile, ce registre pointe sur la pile. Comme je ne vous ai pas encore expliqu ce qu'est la pile, j'y reviendrai plus tard. ES pour segment extra, ce registre est utile pour la manipulation de donnes entre plusieurs segments en parallle des registres DS, FS et GS. FS et GS pour segment extra, ces registres ont les mmes fonctionnalits que le registre DS. Il est disponible partir des processeurs 80386. Dans le registre CS est stocke ladresse de segment de la prochaine instruction excuter. La raison pour laquelle il ne faut surtout pas changer sa valeur directement est vidente. De toute faon, vous ne le pouvez pas. Le seul moyen viable de le faire est dutiliser des instructions telles que des sauts "JMP"
Page 41
ou des appels "CALL" vers un autre segment. CS sera alors automatiquement actualis par le processeur en fonction de ladresse darrive. Le registre DS est quant lui destin contenir ladresse du segment des donnes du programme en cours. On peut le faire varier condition de savoir exactement pourquoi on le fait. Par exemple, on peut avoir deux segments de donnes dans son programme et vouloir accder au deuxime. Il faudra alors faire pointer DS vers ce segment. ES est un registre qui sert adresser le segment de son choix. On peut le changer aux mmes conditions que DS. Par exemple, si on veut copier des donnes dun segment vers un autre, on pourra faire pointer DS vers le premier et ES vers le second. Le registre SS adresse le segment de pile. Il est rare quon doive y toucher car le programme na quune seule pile. On ne peut pas mettre directement une valeur immdiate dans un registre de segment, le microprocesseur ne le permet pas:
Par contre :
Registres doffset Il y a deux registres d'index et trois de pointeurs de 16 bits : SI (Index de source) et DI (Index de destination). Ils sont souvent utiliss comme des pointeurs, mais peuvent tre utiliss pour la plupart des mmes choses que les registres gnraux. Cependant, ils ne peuvent pas tre dcomposs en registres de 8 bits. Les registres 16 bits BP (Pointeur de base) et SP (Pointeur de pile) sont utiliss pour pointer sur des donnes dans la pile du langage machine et sont appels le pointeur de base et le pointeur de pile, respectivement. Nous en reparlerons plus tard. Le registre IP (Pointeur dinstruction) contient le dplacement entre le dbut du registre CS et la prochaine instruction que doit excuter le processeur (Il peut tre dangereux de manipuler ce registre car, de par sa fonction, une mauvaise utilisation risque dentraner un plantage de votre programme).
Page 42
Le registre de pointeur d'instruction IP est utilis avec le registre CS pour mmoriser l'adresse de la prochaine instruction excuter par le processeur. Normalement, lorsqu'une instruction est excute, IP est incrment pour pointer vers la prochaine instruction en mmoire. Pour ces registres, on trouve galement la capacit de dcoupage des registres de 32 16 bits prcdemment nonc dans sur la section des registres gnraux. Registre de flag Un programme doit pouvoir faire des choix en fonction des donnes dont il dispose. Pour cela, il lui faut par exemple comparer des nombres, examiner leur signe, dcouvrir si une erreur a t constate, etc. Il existe cet effet de petits indicateurs, les flags qui sont des bits spciaux ayant une signification trs prcise. De manire gnrale, les flags fournissent des informations sur les rsultats des oprations prcdentes. Ils sont tous regroups dans un registre: le registre des indicateurs. Comprenez bien que chaque bit a un rle qui lui est propre et que la valeur globale du registre ne signifie rien. Le programmeur peut lire chacun de ces flags et parfois modifier leur valeur directement. En mode rel, certains flags ne sont pas accessibles. Nous nen parlerons pas. Nous ne commenterons que les flags couramment utiliss. Nous verrons quelle utilisation on peut faire de ces indicateurs dans la troisime partie de ce tutoriel. Le registre flags permet de fixer et ce connatre ltat du processeur grce aux diffrents bits qui le composent, ce qui permet ainsi davoir tout instant ltat rsultant de lexcution dune opration par le microprocesseur. La plupart des instructions affectent ce registre. Chaque bit relate ltat spcifique de la dernire instruction excut. Aprs lutilisation de certaines instructions, il est affect et ltat de ses diffrents bits permet de prendre des dcisions, par exemple choix lors de branchement conditionnel (boucle et saut) pour vrifier sil y a une retenue aprs une opration arithmtique. Le registre FLAGS est compos de 32 bits galement appel indicateur : 15 0 14 NT 13 12 11 OF 10 DF 9 IF 8 TF 7 SF 6 ZF 5 0 4 AF 3 0 2 PF 1 1 0 CF Bit Appellation
IOPF
Les 16 premiers bits (0 15) sont considrs comme les bots de drapeau. 31 30 29 28 27 26 25 24 23 22 21 ID 20 VIP 19 VIF 18 AC 17 VM 16 RF
Les case qui sont grises correspond aux bits rservs ou non dfinis par Intel. EFLAGS est un registre en deux groupes de bits indicateurs.
Page 43
CF (Carry Flag), en franais indicateur de retenue. Ce bit est positionn ltat haut 1 sil y a une retenue lissue de lexcution dune opration arithmtique.
PF (Party Flag), indicateur de parit. Ce bit est positionn ltat haut 1 si le rsultat dune opration est un nombre pair de bit mis 1.
AF (Auxiliary Flag), retenue auxiliaire. Ce bit est positionn ltat haut 1 si, aprs une opration, il y a une retenue.
ZF (Zero Flag), indicateur de zro. Ce bit est positionn ltat haut 1 si, aprs une opration, le rsultat est nul.
SF (Sign Flag), indicateur de signe. Ce bit est positionn ltat haut 1 si, aprs une opration, le rsultat est ngatif.
IF (Interrupt Flag), sert empcher les appels dinterruptions lorsquil est positionn 1. Cependant, toutes les interruptions ne sont pas masquables.
OF (Overflow Flag), indicateur de dbordement de capacit. Ce bit est positionn ltat haut 1 si, aprs une opration, le rsultat dborde la capacit du registre. Prenons, par exemple, laddition de la valeur 0FFFFh maximale qui peut tre stocks dans un mot de 16 bits avec une valeur 1 quelconque : 0FFFFh + 1h = 10000h. Le rsultat de cette addition est la valeur 10000h et ce nombre ne tient pas sur 16 bits ! Il y a donc un dpassement ! Cet indicateur sert galement signaler des dbordements lors de lutilisation darithmtique sign (-32767 32768 contre 0 65535).
Il en existe dautres part ceux quon a vu prcdemment, ce sont les registres MMX et SIMD mais nous ne les utiliserons pas ici.
Les registres MMX et SIMD
Page 44
Les applications multimdias et de communication devenant de plus en plus gourmandes en calcul, les fondeurs de microprocesseurs ont t obligs de penser une nouvelle faon d'utiliser les donnes. Ces registres sont ddis la manipulation des donnes multimdias, ils sont en virgule flottante. Les registres MMX sont disponibles depuis les Pentium MMX, ils ont une capacit de 64 bits. Les registres SIMD sont des versions tendues 128 bits des registres 64 bits MMX. Les registres SIMD ne sont disponibles que depuis les Pentium III. Les huit registres MMX MM0 MM7 ; Les huit registres SIMD XMM0 XMM7.
A noter que certains assembleurs ne grent pas les dernires volutions des processeurs 80x86 dIntel, et en particulier la gestion des 8 registres SIMD, et des 47 instructions qui en permettent la manipulation.
Les registres spcialiss Il existe un certain nombre de registres qui sont faiblement documents. Ces registres existent depuis le 386, ils servent entre autre pour la gestion du mode protg et la mise au point des programmes. Les cinq registres de contrle sont CR0 CR4 (Control Register). Les huit registres de mise au point (Debug) sont DR0 DR7 (Debug Register). Les cinq registres de teste sont TR3 TR7 (Test Register). Le registre GTDR (Global Descriptor Table Register). Le registre ITDR (Interrupt Descriptor Table Register). Le registre LDTR (Local Descriptor Table Register). Le registre TR (Task Register).
La pile La programmation d'un ordinateur ncessite l'usage (d'au moins) une pile. Une pile est une rgion de la RAM o lon va stocker ou retirer des informations, elle est structure linairement et dont on ne peut manipuler que le sommet, l'image d'une pile d'assiettes : vouloir retirer une assiette du milieu conduit la catastrophe. La seule mthode d'accs consiste empiler ou dpiler des assiettes partir du sommet de la pile. Une telle structure permet de conserver en mmoire l'ordre selon lequel on y a stock des informations. En les dpilant, l'ordinateur se retrouve dans l'tat ou il y tait avant les oprations qui ont conduit des empilements successifs. L'assembleur vous fera manipuler une pile qui
Page 45
est stocke "en fond de panier", cest dire dans les adresses les plus hautes de la mmoire. (Correspondant aux 640 Ko). Une petite particularit : La base de la pile se trouv l'adresse maximale, et elle s'accrot vers les adresses basses. A l'inverse, les programmes se dveloppent sur le "tas", en bas de mmoire, juste au dessus de la zone rserve pour le systme. Pile et Tas croissent donc l'inverse l'un de l'autre. Lutilisation de la pile est trs frquente pour la sauvegarde temporaire du contenu des registres et pour le passage de paramtres lorsquun langage de haut niveau fait appel une routine en assembleur. La taille de la pile varie en fonction de la quantit dinformations quon dpose ou quon en retire. Dans l'architecture x86 32bits, le registre ESP sert indiquer l'adresse du sommet d'une pile dans la RAM. Les instructions "PUSH" et "POP" permettent respectivement d'empiler et de dpiler des donnes. Les instructions "CALL" et "RET" utilisent la pile pour appeler une fonction et la quitter par la suite en retournant l'instruction suivant immdiatement l'appel. En cas d'interruption, les registres EFLAGS, CS et EIP sont automatiquement empils. Dans le cas d'un changement de niveau de priorit lors de l'interruption, les registres SS et ESP le sont aussi.
La mmoire La mmoire est la partie de lordinateur dans laquelle les programmes et les donnes sont rangs. Sans mmoire, dans laquelle le processeur lit et crit de linformation, il ny aurait pas dordinateurs tels que nous les connaissons. Une mmoire est form dun certain nombre de cellules (ou cases), chacune de
Page 46
ces cellules contenant une certaines quantit dinformations. Chaque cellule a un numro, que nous appellerons son adresse, qui permet un programme de la rfrencer. Une analogie consiste comparer la mmoire une longue range de tiroirs alignes les un derrire les autres. Si on donne chaque tiroir un numro, en commenant par 0 pour le 1r tiroir, on dira que ce numro est l'adresse de la mmoire, dans la suite on parlera d'adresse mmoire. La coutume est (de nombreux avantages la justifie) de noter les adresses mmoires en hexadcimal. L'unit mmoire de base est l'octet. Un ordinateur avec 3 Go de mmoire peut stocker jusqu' environ 3 milliards d'octets d'informations. 0 3A 1 11 2 B1 3 8A 4 EF 5 6A N-1 AB
Adresses Mmoire Ce qu'il est important d'avoir l'esprit, c'est que le microprocesseur a besoin de mmoire pour travailler : c'est dans la mmoire qu'il va lire son programme, crire des valeurs... La pagination mmoire Les processeurs IA-32 sont dots dune fonction appele pagination. Elle permet un segment dtre divis en blocs mmoire, appels pages et mesurant tous 4096 octets. Le mcanisme de pagination permet lexploitation par tous les programmes qui fonctionnent En mme temps en espace mmoire apparemment plus vaste que la mmoire physiquement install sur lordinateur. Lensemble des pages est parfois appel la mmoire virtuelle. Un systme dexploitation moderne dispose normalement dun programme appel le gestionnaire de mmoire virtuelle (VMM,
Virtual Memory Manager).

La pagination constitue une solution technique de premire importance un problme rencontrent sans cesse les programmeurs et les concepteurs de matriels. En effet, pour pouvoir excuter un programme, il faut le charger en mmoire, mais la mmoire est coteuse. Lutilisateur veut pouvoir lancer plusieurs programmes la fois et basculer entre lun et lautre. En revanche, lespace disque est beaucoup mois coteux. La pagination donne lillusion de disposer dune quantit quasi illimite de mmoire vive. En revanche, une partie de la mmoire tant remise sur disque dur, les accs sont beaucoup moins rapides quavec la mmoire relle.
Page 47
Pendant lexcution dune tche, il est possible de stocker certaines parties du programme sur disque si elles ne sont pas en cours dexcution. Le rsultat de cette opration est le remisage disque (swapping) de pages. La portion de la tche qui est en cours dexcution doit rester en mmoire. Lorsque le processeur besoin dexcuter les instructions qui se trouvent dans une page qui a t remise sur disque, il provoque une faute de page, ce qui force relire depuis le disque la page de code ou de donnes pour la placer en mmoire. Pour voir comment fonctionne ce systme, vous devez disposer dun ordinateur dans la quantit de mmoire vive nest pas suffisante (32 ou 64 Mo) puis lancer entre cinq et dix applications. Vous remarquerez un ralentissement des performances lorsque vous basculez dun programme lautre, car le systme dexploitation doit dporter des portions des applications de la mmoire vers le disque. Cest pour cette raison quun ordinateur fonctionne plus vite lorsquil est dot dune plus grande quantit de mmoire vive : cela vite de recouvrir trop souvent au mcanisme de pagination en laissant une plus grande portion de chaque application en mmoire.
Organisation de la mmoire La mmoire des x86 est organise selon deux principes : Le mode segment. Le mode protg.
Le premier style est le mode par dfaut de tous les processeurs x86. Ce style est contraignant dans son fonctionnement, mais il nest pas ncessaire, contrairement au mode protg, de se lancer dans de lourdes routines dinitialisation mal matrises. Ce style par dfaut pourrait tre nomm mode dadressage segment. En effet, la mmoire dans ce mode nest pas un long et unique bloc, mais une suite de "segment" Les segments ont une taille limite de 64Ko. Cette capacit dadressage de 65 535 octets est due la limite des 16 bit des premiers processeurs 8086. A lpoque, en 1981, un processeur qui tait capable dadresser plus de 64 ko, ctait trs fort, et le prix de la RAM tait prohibitif ! Pour trouver ladresse relle de la mmoire, il faut une valeur de positon appel en anglais "offset" (dcalage). Cet offset est donc le dplacement qui existe entre le premier octet du segment et loctet de la mmoire qui est pointe. A partir de ces deux valeurs SEGMENT: OFFSET, on peut localiser nimporte quel octet dans la mmoire adressable par le processeur. Exemple A000h:0000h
Page 48
Le second style dadressage de la mmoire de ces nouveaux processeurs est spcifique du mode protg. Une fois que le processeur est initialis en mode protg, la mmoire est adressable dun seul bloc de 4Go. Lorsquils ont conu le mode protg, les ingnieurs dIntel en ont profit pour se dbarrasser dune srieuse limitation de leurs processeurs jusqualors en mode protg : La limitation dadressage mmoire de 1Mo a disparu. Il devient possible dadresser 16Mo sur 80286 et 4Go partir du 80386. Par ailleurs, le 80386, dot dun bus sur 32 bits, dispose de nouveaux modes dadressage mmoire. A partir du 80286, le processeur dispose dinstructions pour la commutation des tches; cette opration devient ds lors trs simple programmer et ainsi plus fiable. Ces processeurs comportent aussi une gestion automatique de la mmoire virtuelle, pas trs intressante sur 80286, mais relativement performante sur 80386. Le processeur a aussi la capacit de simuler autant de processeurs en mode rel que lon souhaite et de leur allouer chacun 1 Mo de mmoire. Cest ce qui se passe lorsquon lance un programme DOS sous Windows. Les programmes excuts ont limpression de tourner sur un processeur indpendant, avec un mmoire indpendante. Les programmes Win32 fonctionnent en mode protg depuis le 80286. Mais le 80286 c'est maintenant de l'histoire ancienne. Donc nous devons seulement nous intresser au 80386 et ses descendants. Windows dirigent chaque programme Win32 sparment. Ceci signifie que chaque programme Win32 aura sa disposition ses propres espaces de mmoire. Cependant, cela ne signifie pas que chaque programme win32 a 4GB de mmoire physique, mais seulement que le programme peut adresser n'importe quelle adresse dans cette gamme. Windows fera tout le ncessaire pour adresser les vraies rfrences (physiques) du programme aux adresses mmoires valables 00401000 qu'il utilise. Bien sr, le programme doit respecter les rgles de Windows, autrement il causera une Erreur de Protection Gnrale tant redoute. Chaque programme est seul dans son espace d'adresse. C'est la diffrence avec les programmes Win16. Tous les programmes Win16 peuvent malheureusement plus ou moins se chevaucher les uns les l'autres. Mais pas sous Win32. Ces gardes fous rduisent la chance d'une criture du code d'un programme par dessus les donnes d'un autre. Le modle de mmoire est aussi rsolument diffrent des vieux jours du monde du 16 bits. Dsormais, sous Win32, nous ne sommes plus concerns par le modle de mmoire en plusieurs segments! (0001.xxxx puis 0002.xxxx puis 0003.xxxx) L'assembleur 32 bits est la fois plus clair et plus simple que le DOS et il n'est pas handicap par l'arithmtique des segments. Vous n'avez plus vous soucier des paires de registres comme AX:DX pour les entiers longs et il n'y a plus la limitation des segments de mmoire 64 Ko qui existait dans la segmentation 16 bits. Il y a seulement un seul modle de mmoire : le modle de mmoire uniforme (Flat). La mmoire est un seul espace continu.
Page 49
a veut dire aussi que vous n'avez plus besoin de jouer avec les diffrents registres concernant les segments [ES et SS]. Vous pouvez employer n'importe quel registre de segment pour adresser n'importe quel point dans l'espace de mmoire (ouf !). C'est une grande aide pour les programmeurs. C'est ce qui fait de l'assembleur Win32 une programmation aussi facile que le C. Quand vous programmez sous Win32, vous devez respecter quelques rgles importantes. Une rgle majeure est que Windows emploie lui-mme ESI, EDI, EBP et EBX et les valeurs de ses registres changent, en mme temps qu'une autre application tourne en parallle avec Windows. Rappelez-vous donc cette rgle primordiale d'abord : si vous employez chacun de ces quatre registres l'intrieur d'une procdure, n'oubliez jamais de les reconstituer "rtablir" avant le contrle de retour Windows. L'exemple vident ce sont les Call qui appellent une API de Windows. Cela ne signifie pas que vous ne pouvez pas employer ces quatre registres, vous le pouvez. Mais seulement que vous devez rtablir ces registres aprs un call.
Chapitre3 : Instruction du microprocesseur Les instructions des x86 sont trs nombreuses et il nest pas question de les dvelopper toutes dans ce guide. Nous dtaillerons dans chapitre uniquement les instructions classiques, c'est--dire celles qui sont les plus importantes pour une initiation la programmation courante en assembleur. Dans ce chapitre, nous dvelopperons le fonctionnement des instructions du microprocesseur et nous agrmenterons ces descriptifs par quelques courts exemples de mise en situation. Nous approfondirons un certain nombre de ces instructions. Pralablement, nous verrons quelques prcautions dusage lies lemploi et au maniement des instructions, des directives et de certains mots rservs. Ces avertissements engloberont les conventions de lecture et dcriture des diffrents champs dvelopps. Anatomie dun programme en assembleur Et oui, comme toute "langue vivante", l'assembleur possde des propres rgles de "grammaire" et d'"orthographe". Et gare vous si, dans un dsir d'indpendance tout fait mal propos, vous dcidez de ne pas y plier! Ceci dit, ces rgles sont trs simples et il faudra qu'un peu d'habitude pour les connatre. Mieux mme, ces programmes que jusqu' maintenant vous considriez tre du chinois en seront rduit n'tre
Page 50
finalement que de l'anglais: on tombe vraiment dans la facilit! Nous pourrons distinguer deux sortes deux rgles dans la programmation en assembleur : Les rgles absolues: si par malheur vous les transgresser, vous vous ferez froidement jeter par la machine avec en guise de compliment de petits mots d'amiti de type "ILLEGAL FORMAT", "MISSING OPERAND", le tout dans le plus pur anglais de Shakespeare; Les rgles conseilles: ce sont celles qui sont laiss l'apprciation du client. En gros, si vous ne les saviez pas, vous risquez : d'une part de passer beaucoup de temps que ncessaire pour faire tourner un programme. d'autre part de devoir vous reporter au chapitre consacr au code erreur par suite d'une tourderie ce qui est trs dsagrable. Structure des instructions Un programme en assembleur a une forme bien particulire. Chaque ligne dun code source assembleur comporte une instruction. Chaque ligne est compose de champs. De gauche droite, on a :
Etiquette Dbut:
Mnmonique
MOV
Oprande destination
EAX
Oprande source
EBX
Commentaire ; EAX <- EBX
Le champ tiquette, qui peut tre vide. Le champ mnmonique (obligatoire) Le champ oprande, par exemple EAX, BX, DH, CL, MonCompteur, 10 (normalement obligatoire) Et dun champ commentaire, qui peut tre vide.
Dcouvrons chaque partie dune instruction, en commenant par le champ dtiquette.
tiquette
Page 51
Une instruction peut tre prcde d'un identificateur qui reprsente l'adresse de stockage de cette instruction. On appelle cet identificateur une tiquette (label en anglais). Il label permet un reprage plus ais lintrieur du programme. Le nom du label est arbitraire. Vous pouvez le nommer comme a vous chante tant qu'il est unique et ne viole pas la convention de nom de lassembleur. Par exemple vous ne pouvez pas prendre le mot 'MOV' comme nom de label. Nutilisez pas de labels qui peuvent tre confondus avec dautres labels. Evitez les lettres I, O, Z, et les chiffres 0, 1, 2. Evitez aussi des labels tels que XXXX et XXXXX car on ne les diffrencie pas aisment.
Example:
Mnmonique Un mnmonique dinstruction est un mot court qui identifie une instruction. Les mnmoniques du langage assembleur sont dorigine anglaise. Les lecteurs franais retrouvent nanmoins de nouveaux lments communs avec leur langue. Oprandes La syntaxe assembleur Intel x86 dfinit loprande de gauche comme oprande destination, celui dans lequel on trouve le rsultat de linstruction. Loprande de droite est appel oprande source. Le champ oprande est un champ optionnel selon linstruction (Une instruction peut avoir entre zro et trois oprandes). Dans la plupart des assembleurs, il ne peut y avoir quune seule instruction par ligne. Chaque oprande tre le nom dun registre, une constante, une expression constante ou un emplacement mmoire. Exemple 13 2+6 eax Type doprande Constante Expression constante Registre
Page 52
Compteur
Emplacement mmoire
Ecrire des commentaires dans le programme Aujourdhui, vous savez exactement comment votre programme fonctionne. Nanmoins, si quelquun dautre le lit ou si vous le relisez vous-mme quaprs quelque temps (vous aurez peut-tre oubli le rle de telle ligne ou telle fonction), vous serez lun comme lautre dy trouver des commentaires explicatifs. Ces commentaires expliquent (en franais ou dans toute autre langue que vous parlez) ce que se passe dans le programme crit en langage informatique. Ainsi, un commentaire est un texte ajout au code source dun programme servant dcrire le code source, facilitant sa comprhension par les humains. Il est donc spar du reste du code grce une syntaxe particulire. La norme est le point virgule (;). Le positionnement de se sigle dans une ligne implique que tout le texte qui se trouve sa suite est considr comme un commentaire. Ce texte ne sera donc pas trait lassemblage. Certains assembleurs tolrent la syntaxe dautres langages comme le C, cest--dire les couples de caractres : // et /* */. Mais je vous conseille de respecter la norme assembleur dans un souci de compatibilit entre assembleurs. Vous avez dj vu des exemples des commentaires dans les exemples de programmes que nous avons prsents, voici un exemple de code incluant des commentaires :
Lisibilit et prsentation
Page 53
Lassembleur ne diffrencie pas majuscules et minuscules, et ne tient pas compte du nombre d'espaces. Les instructions suivantes sont identiques et correctes : Exemple :
La lisibilit du code source a un impact direct sur la faon dont un dveloppeur comprend un systme logiciel. La maintenance de code dsigne la facilit de modifier un systme logiciel pour ajouter de nouvelles fonctionnalits, modifier des fonctionnalits existantes, corriger des bogues ou amliorer les performances. Bien que la lisibilit et la maintenance rsultent de plusieurs facteurs, la technique de codage reprsente une partie spcifique du dveloppement de logiciel sur laquelle tous les dveloppeurs peuvent avoir une influence, il est donc fortement conseill, voire absolument indispensable, dtre un minimum rgulier et strict dans la prsentation des programmes sources. Aussi, il suffit de respecter une prsentation uniforme et rgulire, et dappliquer pour cela des rgles lmentaires, qui ne sont pas spcifiques lassembleur : Commenter correctement le fichier du code source. Ne pas tomber dans la facilit en commentant ce que fait linstruction, mais dire quoi elle sert. Il ne faut non plus tre avare dans les commentaires ainsi quau niveau de laration du code source, Ne pas hsiter sauter des lignes pour mieux visualiser les blocs dinstructions. Toutes ces modifications ne seront pas assembles et noccultent donc pas les performances de lexcutable, et elles feront la diffrence au moment de la relecture du code source. Appliquer les tabulations pour amliorer la lisibilit du code source, Ainsi, essayer de respecter des colonnes imaginaires ddies aux tiquettes, mnmoniques, oprandes et commentaires. User des majuscules bon escient. Il est prfrable de rserver par exemple les mots en majuscules aux dclarations de constantes.
Page 54
Utiliser les bonnes bases numraires afin damliorer la lecture du code. En effet, lhomme ne lit pas naturellement et aussi facilement le binaire ou lhexadcimal que le dcimal. Surtout pour les grandes valeurs. Il est possible de mettre ces valeurs lisibles dans les commentaires.
Essayer de casser la linarit du code source car il est relativement lourd danalyser un fichier source qui nest quune longue suite dinstructions. Pour cela, il faut essayer de faire des modules, de commenter par blocs. Ce qui se traduit par des sparations des commentaires grce des lignes de tirets. Nous verrons cela en dtail dans le paragraphe qui traite la programmation modulaire.
Notes et abrviations Chaque instruction liste dans ce chapitre est dcrite selon un mme modle, compos de diffrents champs faisant rfrence aux notions : drapeaux et oprandes. Comme nous lavons dj vu, le microprocesseur possde un registre particulier quest le registre flag. La plupart des instructions modifient les indicateurs du registre EFLAGS. Un tableau indique leffet de linstruction couramment dcrite sur ces indicateurs. Il a la forme suivante ; OF DF IF TF SF ZF AF PF CF
Pour indiquer ltat de chaque bit composant les flags de ces tableaux, nous avons choisi les signes suivants : 0 indique un bit est positionn 0. 1 indique un bit est positionn 1. * le bit est modifi en fonction du rsultat de lexcution de linstruction (0 ou 1). ? indique un bit positionn de manire non prvisible et mis 0 ou 1 par linstruction. Une case vide indique que lindicateur nest pas modifi par linstruction.
Page 55
Par exemple, dans le tableau suivant, rsultat de passage de linstruction OR, on peut en dduire quil est compos de : OF 0 DF IF TF SF * ZF * AF ? PF * CF 0
A la lecture de ce tableau, on peut dire que la direction est interne, il ny a pas dinterruption, il ny a pas dexcution pas pas, le signe, le zro, la parit sont fonction de lexcution. Enfin, la retenue auxiliaire est variable. Le dbordement et la retenue sont annuls.
Oprandes Pour chaque instruction, on utilisera des oprandes afin de visualiser les paramtres de fonctionnement de chacune. On trouve des mmoires et des registres classiques. Reg8 dsigne un registre 8 bits : AL, AH, BL, BH, CL, CH, DL, DH. Reg16 dsigne un registre 16 bits : AX, BX, CX, DX, DI, SI, BP, SP. Reg32 dsigne un registre 32 bits : EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP. Accum dsigne laccumulateur qui peut tre AL, AX ou EAX selon la taille de lopration. Mem16 dsigne un emplacement mmoire de 16 bits. Mem32 dsigne un emplacement mmoire de 32 bits. Immed8 dsigne une valeur immdiate de 8 bits. Immed16 dsigne une valeur immdiate de 16 bits. Immed32 dsigne une valeur immdiate de 32 bits.
Liste des instructions par fonctionnalits Cette liste rcapitule les instructions que nous connaissons dj et en prsente de nouvelles. Elle nest pas exhaustive mais vous sera amplement suffisante pour la plupart de vos programmes. Instructions de dplacement et daffectation
Page 56
Les instructions de dplacement et daffectation de donnes permettent de manipuler des blocs de donnes dun endroit lautre de la mmoire. La taille des donnes dplaces peut tre de type : octet (8 bits), mot (16 bits), double mot (32 bits), quadruple mot (64 bits), et mme des groupes dun des types prcdents. Ce transfert peut tre effectu de plusieurs manires : Dun registre vers la mmoire ; De la mmoire vers un registre ; Dun registre vers un registre ; De la mmoire vers la mmoire ;
Voici la liste des instructions de dplacement et daffectation : BSWAP, XMPWCHG, CAMPXHG8B, IN, LDS, LES, LFS, LSS, LEA, LODSB, LODSW, MOV, MOVSB, MOVSW, MOVSD, MOVSX, MOVZX, PUSH, PUSHA, PUSHAD, POP, POPA, POPAD, STOSB, STOSW, STOSD, XLAT.
Instructions logiques et arithmtiques Les instructions arithmtiques et logiques sont effectues par l'unit arithmtique et logique. Il s'agit d'oprations directement effectues sur les bits de la donne que l'on traite. Sont comprises dans cette appellation : Les instructions d'addition ; Les instructions de soustraction ; Les instructions de multiplication ; Les instructions de division ; Les instructions logiques (ET, OU, ...) ;
Les oprations arithmtiques et logiques modifient l'tat des indicateurs. Voici la liste des ces instructions : AAA, AAD, AAM, ADC, ADD, SUB, SBB, CBW, CWD, CWDE, CQD, DAA, DAS, DEC, INC, MUL, DIV, IMUL, IDIV, AND, OR, XOR, NOT, NEG.
Page 57
Faites attention lemploi des instructions lies lusage des nombres signs, faites la distinction avec les instructions ddies aux nombres non signs. Cela ne sapplique quaux oprations de multiplication et de division. En effet, les manipulations de nombres signs ngatifs partir daddition ou de soustraction ne sont en fait que des traitements de complments 2.
Instructions de manipulation de bits Ces instructions permettent une manipulation directe des bits, un un ou par groupe. Il faut remarquer que ces instructions fonctionnent sans lemploi des oprations logiques (AND, not, or, etc.) Cette capacit travailler de cette manire sur les bits est une spcificit de lassembleur. Instructions de dcalage On distingue trois groupes dinstructions dans cet ensemble. Le premier groupe permet le dcalage des bits prsents dans un groupe (octet, mot ou double mot). La direction du dcalage peut tre fixe vers la droite ou la gauche ou de plusieurs bits. SAL, SHL, SAR, SHAR, SHLD, SHRD. Le deuxime groupe est spcialis dans les rotations de bit dans un mme octet, mot ou double mot. ROR, ROL, RCL, ROR.
Instructions de traitement Le troisime groupe est constitu des instructions de traitement. C'est--dire les instructions permettant de manipuler les bits directement, de changer leu tat (0, 1), deffectuer des tests. BT, BTC, BTR, CLC, STC, CMC, CLD, STD, CLI, STI.
Instructions de contrle et de test Nous sommes sur le point daborder une partie intressante, dans la mesure ou elle permet de comprendre la raction du programme suite la valeur du rsultat (0 ou 1). Nous allons maintenant nous intresser aux conditions. Sans conditions, nos programmes informatiques feraient un peu toujours la mme chose, ce qui serait carrment barbant la fin.
Page 58
Dans la vie, on a souvent besoin de dcider du droulement des choses en fonction de certaines conditions. Par exemple : "Sil pleut, je prends mon parapluie" (ceci n'a d'ailleurs de sens que si je souhaite sortir !). De mme en Assembleur, il est possible de dcider de n'excuter une action que si une condition particulire est remplie. Pour tester si une condition est vraie avant d'excuter une action, on dispose des instructions permettent dactiver des branchements "saut", avec ou sans fonction de test et de choix. Le droulement du programme est alors dvi de son chemin courant vers un autre, spcifique du choix. On distingue ces instructions de saut en deux catgories suivant que : Le saut est effectu quoi qu'il arrive saut inconditionnel . Le saut est effectu ou non selon l'tat d'un registre saut conditionnel .
Saut inconditionnel Ce sont des branchements obligatoires, le processeur saute directement ladresse destination. Il procde aux sauts sans aucun test prliminaire. Cela comprend galement lutilisation des interruptions. JMP, CALL, RET, INT, IRET
Saut conditionnel Ces branchements sont effectifs aprs validation dune condition. Il saute ladresse seulement si la condition est vraie. Dans le cas contraire, lexcution se poursuit avec linstruction suivante. Ces instructions sont lies aux instructions de test. LOOP, JCC, REP.
Test Ces instructions permettent la comparaison de deux oprandes passs en paramtre et, en fonction du rsultat du test, positionnent les flags (CF, SF, AF, etc.). Ces instructions sont lies aux instructions de saut conditionnel. CMP, TEST.
Page 59
Pour les exemples qui vont suivre, je vais vous dcrire l'instruction la plus utilise dans le microprocesseur: MOV
MOV registre1, registre2 a pour effet de copier le contenu du registre2 dans le registre1, le contenu
pralable du registre1 tant cras. Cette instruction vient de l'anglais move qui signifie dplacer mais attention, le sens de ce terme est modifi, car l'instruction MOV ne dplace pas mais place tout simplement. Cette instruction ncessite deux oprandes qui sont la destination et la source. Ceux-ci peuvent tre des registres gnraux ou des emplacements mmoire. Cependant, les deux oprandes ne peuvent pas tre toutes les deux des emplacements mmoire. De mme, la destination ne peut pas tre ce qu'on appelle une valeur immdiate (les nombres sont des valeurs immdiates, des valeurs dont on connait immdiatement le rsultat) donc pas de MOV 10, AX. Ceci n'a pas de sens, comment pouvezvous mettre dans le nombre 10, la valeur dAX ? 10 n'est pas un registre.
Exemples :
Remarque : Il est strictement interdit de transfrer le contenu dune case mmoire vers une autre case mmoire comme suit :
Pour remdier se problme on va effectuer cette opration sur deux tapes :
On na pas le droit aussi de transfrer un registre segment vers un autre registre segment sans passer par un autre registre :
On va passer comme la premire instruction :
Page 60
Le CS nest jamais utilis comme registre destination. Une autre rgle respecter, les oprandes doivent tre de la mme taille donc pas de MOV AX, AL ou MOV EBX, DX cela me semble assez logique. On ne peut pas utiliser une valeur immdiate avec un registre de segment (MOV ES, 5 : impossible mais MOV ES, AX : possible).
Voil ! Une partie pnible de terminer. Par contre, je n'en ai pas dtaill pour le moment les instructions car je pense que vous comprendrez mieux le moment venu, avec un exemple concret d'utilisation. Je suis bien conscient que ces chapitres taient riches en vocabulaire, en nouveauts mais bon, voil : votre calvaire... ne fait que commencer. Eh oui : tout ceci tait un amuse-bouche ! Maintenant, nous rentrons dans le vif du sujet. Cela fait dj une bonne base pour commencer. Si vous connaissez dj tous a sur le bout des doigts, vous tes bien parti. D'ailleurs j'en profite pour vous rappeler qu'il est ncessaire de connaitre ces chapitres pour pouvoir passer aux suivants. En fait, je dirais mme que vous n'y parviendrez pas avant un bon bout de temps... Mais tout arrive avec le temps ;) Donc patience... Et surtout bonne chance ! Et n'oubliez pas que pour apprendre, rien ne vaut la pratique ! Mais rassurez-vous, partir de maintenant tout ce que nous allons faire va apparatre l'cran. J'espre que vous avez encore de l'nergie, car, dans le chapitre suivant, nous aborderons quelque chose de bien plus passionnant... Bon ! Tenez-vous prts pour faire vos premiers codes Assembleur.
Les outils ncessaires au programmeur Pour dvelopper des programmes, il faut des outils. Ces outils sont de plusieurs catgories et plus ou moins performants et complexes en fonction de leur usage. Nous allons expliquer lutilit de chacun dentre eux. Mais avant a, faisons un petit rcapitulatif. Chaque type de processeur comprend son propre langage machine. Les instructions dans le langage machine sont des nombres stocks sous forme octets en mmoire. Chaque instruction son propre code numrique unique appel code d'opration ou Opcode. Les instructions des processeurs x86 varient en taille. L'Opcode est toujours au dbut de l'instruction. Beaucoup d'instructions comprennent galement les donnes (des constantes ou des adresses) utilises par l'instruction. Le langage machine est trs difficile programmer directement. Dchiffrer la signification d'instructions codes numriquement est fatigant
Page 61
pour des humains. Par exemple, l'instruction qui dit d'ajouter les registres EAX et EBX et de stocker le rsultat dans EAX est encode par les codes hexadcimaux suivants : 03 C3 C'est trs peu clair. Heureusement, un programme appel un assembleur peut faire ce travail laborieux la place du programmeur. Un programme en langage d'assembleur est stock sous forme de texte (comme un programme dans un langage de plus haut niveau). Chaque instruction assembleur reprsente exactement une instruction machine. Par exemple, l'instruction d'addition dcrite ci-dessus serait reprsente en langage assembleur comme suit : ADD EAX, EBX Ici, la signification de l'instruction est beaucoup plus claire qu'en code machine. Le mot ADD est une mnmonique pour l'instruction d'addition. Un assembleur est un programme qui lit un fichier texte avec des instructions assembleur et convertit l'assembleur en code machine. Les compilateurs sont des programmes qui font des conversions similaires pour les langages de programmation de haut niveau. Un assembleur est beaucoup plus simple qu'un compilateur. "Cela a pris plusieurs annes aux scientifiques de l'informatique pour concevoir le simple fait d'crire un compilateur, En effet, votre titre dinformation, la conversion du code source en code machine est trs complexe. Elle implique de comprendre comment transcrire un ensemble dinstructions de haut niveau en instructions machine de bas niveau, trs spcifiques. Lorsque le processus est complet, un excutable est cre. Cest ce programme que vous pouvez excuter. Des livres entiers existent sur la faon de convertir les langages de programmation de haut niveau en langage machine. Heureusement pour vous, les vendeurs de compilateurs ont lu tous ces livres : vous navez pas besoin de comprendre comment cela fonctionne Vous avez juste assembler votre code avec un assembleur les programmes que vous avez crits" Si vous dsirez approfondir vos connaissances dans le domaine de la compilation, vous devez essayer : Engineering a Compiler, Keith
Cooper, Linda Torczon. Advanced Compiler Design and Implementation, Morgan Kaufmann.
Chaque instruction du langage d'assembleur reprsente directement une instruction machine. Les instructions d'un langage de plus haut niveau sont beaucoup plus complexes et peuvent requrir beaucoup d'instructions machine. Une autre diffrence importante entre l'assembleur et les langages de haut niveau est que comme chaque type de processeur son propre langage machine, il a galement
Page 62
son propre langage d'assemblage. Porter des programmes assembleur entre diffrentes architectures d'ordinateur est beaucoup plus difficile qu'avec un langage de haut niveau. Comme vous avez srement d constater, chaque famille de processeur utilise un jeu d'instructions diffrent. Il existe beaucoup de langages assembleurs, qui changent selon l'architecture (Intel x86,
MIPS, ARM, Motorola, Zilog, Transmeta, Texas Instruments, VIA, Atmel ) et dans une moindre mesure
selon les systmes d'exploitation (Linux, Windows...). J'ai choisis de se concentrer sur le langage assembleur des processeurs x86 de la famille Intel parce qu'il est utilis sur chaque PC dans le monde et largement le plus populaire de larchitecture des processeurs. Alors votre avis, de quels outils un programmeur a-t-il besoin ? Si vous avez attentivement suivi cette introduction, vous devez en connatre au moins un ! Vous voyez de quoi je parle ? Vraiment pas ? Eh oui, il s'agit de lincontournable assembleur, sujet principal de ce guide, ce fameux programme qui permet de traduire votre langage assembleur en langage machine. Mais cela ne suffit pas ! Il faut dautres outils pour mettre au point les logiciels, quils soient petits ou grands.
Bon, de quoi d'autre a-t-on besoin ? Je ne vais pas vous laisser deviner plus longtemps. Voici le strict minimum pour un programmeur : Un diteur de texte qui vous permet de modifier votre code source sans quitter lenvironnement. Un assembleur permettant de faire la traduction du langage assembleur en langage machine. Un diteur de lien linker permettant la cration du fichier excutable. Un diteur de ressources permettant de crer des ressources Windows telles que des bitmaps, des icnes, des boites de dialogues et des menus. Un dbuggeur pour vous aider traquer les erreurs dans votre programme.
Dtaillons ce baratin : Le programme doit tre saisi dans un fichier texte dextension .asm non format c'est--dire sans caractres en gras, soulign, avec des polices de caractres de diffrentes tailles, ... appel fichier
Page 63
source. En thorie un logiciel comme le Bloc-notes sous Windows fait l'affaire. L'idal, c'est d'avoir un diteur de texte intelligent proposant des fonctions de glisser-dposer, dot dune mise en couleur automatique des mots cls, des commentaires et dautres lments, dune mise en retrait automatique et intelligente , et dune saisie semi-automatique affichant les paramtres de fonctions Windows en cours de frappes, ce qui vous permet de vous reprer dedans bien plus facilement. L'assembleur transforme le fichier source assembleur en un fichier binaire dit fichier objet (code en langage machine, non excutable car incomplet). Il s'agit d'un fichier avec l'extension .obj. Ce fichier contient des instructions et des donnes en langage machine, et chaque donne a un nom symbolique par lequel elle est rfrence. Lditeur de lien lie les codes objets et rsout les rfrences. Cest lui qui produit le fichier excutable. Il li les modules objets, va chercher les fonctions situes dans des bibliothques de fonctions ou de routines. Il permet galement de crer par exemples les librairies .lib, ou les .dll. Si vous avez pass votre nuit sur un programme et que, au matin, rien ne fonctionne encore, vous avez quatre possibilits : Abandonner (dommage). Vous procurer un ordinateur trs trs lent pour essayer de voir ce qui ne va pas durant lexcution du programme (pas bon pas bon). Remplir votre programme dinstructions daffichage de faon quun petit message saffiche aprs lexcution de chaque ligne de code, pour vous annoncer que telle ligne vient dtre excut, ce qui vous permettra de dterminer lendroit o quelque chose se droule mal (a fonctionne mais cest ce quon appelle une galre). Vous employer un dbogueur (cela fonctionne et ce nest pas une galre).
Ban, ds que votre programme dpassera quelques lignes, il est presque certain que vous vous heurtez quelques problmes lors du premier assemblage. Si ce nest pas le cas, vous tes un super programmeur ou vous avez recopi la source dans un livre. Un dbuggeur est un outil qui vous permet dexcuter votre programme ligne par ligne. Cela facilite le contrle de la logique de votre programme et la comprhension de son fonctionnement, la localisation et la correction des erreurs. Bien que le choix du dbogueur soit personnel. Je suggre tous les dbutants de commencer avec un dbogueur comme OllyDbg, qui est un analyser, debugger et assembleur 32 bits avec une interface intuitive. Il est bien puissant et ses plugins lui permettent mme de rivaliser avec le grand SoftIce.
Page 64
Les ressources dfinissent linterface utilisateur du programme Windows. Ce sont elles qui distinguent les programmes Windows des programmes DOS. Les programmes Windows comportent des fentres que lon appelle parfois juste des dialogues, des menus, des bitmaps et toutes sortes de choses qui facilitent lexploitation dun programme. Mais les ressources ne sont pas le propre de Windows : Les systmes dexploitation Macintosh, Unix, OS/2 et bien dautres emploient galement les ressources. Pour faire bref, un programme crit en assembleur doit subir un certain nombre de transformations avant de pouvoir tre excut. La figure suivante prsente les programme en langage d'assemblage. diffrentes tapes du traitement d'un
A partir de maintenant on a 2 possibilits : Soit on rcupre chacun de ces programmes sparment. C'est la mthode la plus complique, mais elle fonctionne. Dailleurs bon nombre de programmeurs prfrent, "utiliser ces programmes sparment" et utiliser un simple fichier .bat pour lancer lassemblage, l'artillerie lourde n'est pas indispensable et les logiciels avec surenchres de fonctionnalits inutiles, c'est juste bon perdre du temps. Une simple fonction "Go To Line" la rigueur est tout ce qu'il faut pour eux. Je ne dtaillerai pas cette mthode ici, je vais plutt vous parler de la mthode simple.
Page 65
Soit on utilise un programme "Tout-en-1" qui combine un diteur de texte, un assembleur, un diteur un lien, un diteur de ressource et un dbuggeur. Ces programmes "Tout-en-1" sont appels IDE, ou encore Environnements de dveloppement Intgr. L'environnement de dveloppement intgr a t conu pour vous permettre de vous dplacer de fentre en fentre et de fichier en fichier de diffrentes faons, selon vos prfrences ou impratifs de projet. Vous pouvez choisir de parcourir tous les fichiers ouverts de l'diteur ou de parcourir toutes les fentres Outil actives dans l'IDE. Vous pouvez aussi basculer directement vers tout fichier ouvert dans l'diteur, indpendamment de son dernier ordre d'accs. Ces fonctionnalits peuvent contribuer accrotre votre productivit lorsque vous travaillez dans l'IDE. Bien que des IDE pour plusieurs langages existent. Bien souvent (surtout dans les produits commerciaux) un IDE est ddi un seul langage de programmation. On peut galement trouver dans un IDE un systme de gestion de versions et diffrents outils pour faciliter la cration de l'interface graphique. Il existe plusieurs environnements de dveloppement. Vous aurez peut-tre un peu de mal choisir celui qui vous plat au dbut. Une chose est sre en tout cas: vous pouvez faire n'importe quel type de programme, quel que soit l'IDE que vous choisissez. Il m'a sembl intressant de vous montrer quelques IDE parmi les plus connus. Tous sont disponibles gratuitement. Personnellement, je navigue un peu entre tous ceux-l et j'utilise l'IDE qui me plat selon l'humeur du jour. Un des IDE les plus connus : RadAsm est une petite merveille, convivial, riche en fonctionnalit, rapide, et d'une taille ridicule par rapport d'autre EDI, il vous permettra de dvelopper de vraies applications avec tout le confort que l'on peut esprer d'une application de qualit. Cest celui l que nous utiliserons tout au long de ce guide. Il existe WinAsm Studio qui ressemble trs fortement RadAsm avec peut-tre un peu moins de fonctionnalits mais dont l'interface et beaucoup plus agrable et facile utiliser. De plus, il se charge beaucoup plus vite et explique clairement comment fabriquer ses propres plugins. AsmEditor est un EDI permettant la cration et la compilation de projets en langage assembleur. Il inclut un contrle des compilateurs permettant de grer autant de chanes de compilations que ncessaire (pour diffrentes plateformes par exemple). Easy Code sous une apparence semblable celle de Visual Basic, me parait aussi quil ferra parfaitement laffaire.
Page 66
Je vous recommande RadAsm, mais ce n'est pas une obligation. Quel que soit l'IDE que vous choisissez vous serez capables de faire autant de choses. Vous n'tes pas limits. Nous avons fait le tour des IDE les plus connus. N'oubliez pas cependant qu'il en existe d'autres et que rien ne vous empche de les utiliser si vous les prfrez. Quel que soit l'IDE choisi, vous pourrez suivre sans problme la suite du cours. On va encore devoir faire un choix sur lassembleur quon devra implmenter dans RadAsm, en effet il existe plus d'une douzaine de diffrents assembleurs disponibles pour le processeur x86 fonctionnant sur PC. Ils diffrent en terme de fonctionnalits et de syntaxe. Certains sont adapts pour les dbutants, certains sont destins uniquement aux programmeurs confirms. Certains sont trs bien documents, d'autres ont peu ou pas de documentation. Certains sont enrichis par beaucoup dexemples de programmation, certains ont trs peu d'exemples de code. Certains assembleurs sont toffs de tutoriels et des livres disponibles qui utilisent leur syntaxe, d'autres en manquent. Certains sont trs basic, d'autres sont trs complexes. Quel est le meilleur assembleur, alors? Comme bon nombre de questions poses dans la vie, il n'y a pas de rponse simple la question Quel est le meilleur assembleur ? La raison en est que diffrentes personnes ont des critres diffrents pour valuer ce qui est le meilleur . A l'absence d'une chelle universelle pour juger les diffrents assembleurs, il n'y a aucun moyen de choisir un seul assembleur et le dsigner le meilleur. Historiquement, MASM, lassembleur de Microsoft, est une volution du premier assembleur 8088 dvelopp pour IBM. MASM a t pendant longtemps la seule solution pour le dveloppeur en assembleur. La dernire version sappelle maintenant ML. Pendant longtemps, la seule vraie alternative a t le Turbo Assembleur (TASM) de Borland, qui fut plbiscit ds sa mise disposition par une grande majorit dutilisateurs pour sa rapidit et sa souplesse. Avec le passage Windows 9x, les outils de dveloppement de type macro-assembleurs nont plus t une priorit pour les diteurs. Ces solutions taient performantes mais payantes. Maintenant, et depuis quelque anne, grce lmancipation des logiciels du monde libre, de nouveaux assembleurs tout aussi performants sont apparus. Le plus connu de ces assembleurs libres est NASM (The Netwide Assembler). Mais il existe galement dautres solutions comme FASM (Flat Assembler), GoAsm, RosAsm, HLA (High level assembly), Gas (GNU
Assembler) Autant le dire tout de suite : il n'y a pas de raison absolue pour prfrer MASM un autre
assembleur. Tous les exemples qui sont dvelopps dans ce guide seront spcifiques MASM en particulier. MASM reste encore aujourd'hui un des assembleurs phare de la communaut des programmeurs en assembleur pour la plateforme Win32, mais d'autres assembleurs rassemblent chacun une communaut importante.
Page 67
MASM supporte une grande varit de macros aidant la programmation en langage assembleur ainsi que des idiomes de programmation structure, incluant des constructions de haut niveau pour les boucles, les appels de procdures, les branchements, etc. ce qui fait de MASM un assembleur programmation de haut niveau.
De nombreux projets supportant MASM ont vu le jour. Ainsi des environnements de dveloppement intgr permettent un dveloppement plus ais avec MASM. De nombreux forums ou sites internet proposent des codes sources de la documentation ou de l'aide concernant cet assembleur qui malgr son anciennet reste un des assembleurs les plus supports.
Le support officiel de MASM par Microsoft se rsume aujourd'hui ajouter des instructions lorsque de nouveaux processeurs voient le jour et amliorer la prise en charge du 64 bits.
La dernire des exigences qui s'ajoutera celles ci-dessus sera remplie, soit en possdent l'ancien fichier d'aide Win32.hlp ou par la mise jour MSDN (Microsoft Developer Network) des bibliothques disponibles en ligne dans le cadre de la Plate-forme SDK (Software Development Kit) disponible en tlchargement libre chez Microsoft. Toutes les Informations que vous pourrez tirer profit dans la suite de ce guide vont se faire en deux catgories principales: MASM32 syntaxe - Comment crire correctement les instructions en ASM sous MASM. L'architecture Windows et ses APIs.
Installation de Masm Une fois que vous avez rcupr Masm, dcompresser o vous voulez, linstallation de Masm ne pose pas de problme mais, pour que chacun soit bien rassur, nous en montrons ici les tapes. Pour dmarrer, lancez install.exe, cette page devrait s'afficher :
Page 68
Cliquer sur Start , pour indiquer que vous acceptez dinstaller Masm dans la racine C:\ et cliquer sur OK . Ensuite, cliquer de nouveau sur OK , La prsence d'un virus dans le package de RadASM est hautement improbable.
Rien de particulier signaler. Cliquez sur OK autant de fois que ncessaire en laissant les options par dfaut, peu de temps aprs, vous devriez avoir une fentre comme celle-ci :
Page 69
Linstallation est maintenant termine avec succs, cliqu sur nimporte quel bouton pour continuer
Pour sassurer que linstallation sest passe sans encombre, vous devriez apparaitre le dossier masm32 dans C:\.
Configuration de RadAsm Dabord, n'hsitez pas consulter le site de l'auteur http://www.radasm.com/ afin d'tre sr de bien rcuprer tous les fichiers archive constituant l'application. Ceux qui nous intressent sont les suivants : RadAsm 2.2.1.6: contient lIDE (ncessaire). RadAsm Assembly programming : si vous utilisez les langages type assembleur (ncessaire). RadAsm language pack : si vous souhaitez traduire l'interface (facultatif).
Vous devez maintenant avoir une archive contenant les trois fichiers. Dcompressez-les o vous voulez, puis vous devriez avoir ceci :
Page 70
Maintenant, il va falloir faire une petite manipulation pour simplifier la suite. Dans le fichier RadLNG, copier le fichier Language dans le fichier RadAsm . De mme mettez le contenu du fichier Assembly dans le fichier RadAsm .
Lancez RadAsm, un fichier sera ouvert automatiquement.
Page 71
Comme tout programme, il y en a eu plusieurs versions. Les captures dcran que je fais sont sur la version 2.2.1.6 comme vous pouvez le voir. Ce genre de programme volue rapidement, mais si vous avez une version suprieure ne vous inquitez pas. Le fonctionnement du programme ne change pas dune version lautre. Oui, par dfaut RadAsm est en anglais. Vous pouvez le modifier en allant en haut dans le menu, Option / Language, choisissez Franais , et enfin Appliquer , OK. Rendez-vous encore sur Option / Langage de programmation, supprimez HTML cala ne servira absolument rien. Cliquez cependant sur le bouton "..." en bas droite. Une nouvelle fentre s'ouvre : choisissez masm.
Page 72
Enfin, confirmer votre modification en cliquons sur Valider.
Page 73
Enfin, il nous reste plus qu indiqu RadAsm lemplacement de Masm, alors pour ce faire, dans Option / Emplacement par dfaut, vous devez simplement remplir les champs suivants. Dans mon cas, c'est :
Cliquez ensuite sur Valider, puis Appliquer.
Crer son premier projet Maintenant que notre environnement est tout fait prt tre utilis. On peut passer l'utilisation. Au dpart, rien ne saffiche. Il va falloir demander RadAsm de crer un nouveau projet. Un projet cest lensemble de tous les fichiers source du programme. En effet, quand on programme, on spare souvent notre code dans plusieurs fichiers diffrents. Ces fichiers seront ensuite combins par lassembleur qui en fera un excutable. Justement, la gestion de projet fait partie des principaux caractristiques dun IDE. Retenez bien la marche suivre, car vous devrez faire cela la plupart du temps. Pour crer un nouveau projet cest simple : allez dans le menu Fichier / Nouveau Projet. Vous devriez voir quelque chose qui ressemble a :
Page 74
On vous demande le nom et la description de votre projet, et dans quel dossier les fichiers source seront enregistrs, que du choix nest ce pas ? Cliquer sur Next deux fois.
Page 75
Veillez ce que Asm soit coch, ensuite cliquez sur Next .
Page 76
Cliquez sur Finish , eh voil, le tour est jou et le projet cr. Vous allez pouvoir commencer crire du code ! Maintenant que ces quelques mots ont t dits, je vais maintenant vous faire faire un tour rapide de l'interface que vous propose RadAsm, en gros, des lments dont nous allons nous servir dans ce guide.
Prsentation rapide de l'interface Avant de commencer, regardez bien les raccourcis clavier prsents dans les menus... Ils sont trs utiles et peuvent vous faire gagner beaucoup de temps. On nest pas obligs bien sr, mais croyez-moi, quand on y a got, on ne peut plus s'en passer Les raccourcis retenir sont : CTRL + SHIFT + N : Nouveau projet
Page 77
CTRL + SHIFT + S CTRL + F5 CTRL + S CTRL + C CTRL + X CTRL + V CTRL + Z CTRL + A CTRL + F
: Enregistrer tous les fichiers : Assembler puis excuter : Enregistrer : Copier la slection : Couper la slection : Coller la slection : Annuler laction prcdente : Slectionner tout : Chercher / Remplacer
Voyons voir plus en dtail comment RadAsm est organis :
Ces 4 icnes sont sans aucun doute les plus utilises, et pour cause : ce sont elles qui permettent dappeler lassembleur pour crer un excutable de votre projet. Dans lordre, de gauche droite, ces icnes signifient : Assembler : tous les fichiers source de votre projet sont envoys au compilateur qui va se charger de crer un excutable. Sil y a des erreurs, lexcutable ne sera pas cr et on vous indiquera les erreurs en bas RadAsm. Construire : quand vous faites Assembler, RadAsm nassemble en fait que les fichiers que vous avez modifis et pas les autres. Parfois, je dis bien parfois, vous aurez besoin de demander RadAsm de vous recompiler tous les fichiers. On verra plus tard quand on a besoin de ce bouton, et vous verrez plus en dtail le fonctionnement de la compilation dans un chapitre futur. Pour linstant, on se contente de savoir le minimum ncessaire pour ne pas tout mlanger. Excuter : cette icne lance juste le dernier excutable que vous avez assembl. Cela vous permettra donc de tester votre programme et voir ainsi ce quil donne. Construire & Excuter : videment, ce bouton est la combinaison des deux boutons prcdents. Cest dailleurs ce bouton que vous utiliserez le plus souvent. Notez que sil y a des erreurs pendant lassemblage (pendant la gnration de lexcutable), le programme ne sera pas excut.
Page 78
Dans l'encadr orange, vous trouverez le dossier de votre projet ainsi que son contenu. Ici, vous pourrez grer votre projet comme bon vous semble (ajout, suppression...). Nous verrons un peu plus tard quels sont les diffrents types de fichiers qui constituent un projet Dans l'encadr bleu, je pense que vous avez devin... C'est ici que nous allons crire nos codes sources. Dans l'encadr rouge, c'est l que vous verrez apparatre le contenu de vos programmes ainsi que les erreurs ventuelles. Et enfin pour finir, dans l'encadr vert, ds lors que nous aurons appris coder nos propres fonctions, c'est ici que la liste des mthodes et des variables sera affich
Page 79
Selon vos gots, vous pourrez ultrieurement personnaliser un certain nombre dautres lments de linterface et de lditeur, en actionnant les commandes du menu Outils : Par exemple, vous pouvez faire en sorte que les numros de ligne apparaissent dans la gouttire (la marge gauche). Notez enfin que vous pouvez allger la barre doutils en choisissant les groupes de boutons qui y apparaissent. Pour cela, cliquez avec le bouton droit de la souris dans la barre doutils (mais pas sur un bouton) : Ce description ne prtend pas tre complte, il s'agissait tout d'abord d'effectuer un tour d'horizon de cet EDI qui je l'espre vous aura permis de mieux le connatre et d'en apprcier la puissance. En outre, certaines fonctionnalits ou options m'ont srement chapp et vous ne manquerez pas de les dcouvrir par vous-mme.
Squelette dun programme en Assembleur Nous en savons prsent suffisamment pour commencer mettre pour de bon les mains dans le cambouis. Ouvrons donc un nouveau projet appel Skeleton. Ce programme nous fournira une base de dpart pour dvelopper n'importe quel programme. Si vous ne comprenez pas quelques-uns des codes, ne paniquez pas. J'expliquerai chacun d'entre eux plus tard.
Nous analyserons maintenant ligne par la ligne. La plupart de ce code reprsente des directives. Certains langages, dont lassembleur, comportent un grand nombre de directives ou instructions ddies la gestion et au contrle des processus de compilation ou dassemblage. Ces directives dont le rle est de contrler et de mettre, place les bons paramtres en vue des diffrentes phases de lassemblage, sont rassembls en plusieurs groupes selon leur fonction. Il faut noter que la prise en charge et la
Page 80
syntaxe de ces directives varient dun assembleur lautre, mme si historiquement la plupart sinspirent de Masm. Les directives font partie de la syntaxe du langage assembleur mais ne dpend pas du jeu dinstructions dIntel. Des programmes assembleurs diffrents peuvent gnrer du code machine identique en ce qui concerne les processeurs Intel, tout en offrant un jeu de directives diffrent. La diffrence entre majuscules et minuscules dans les noms des directives ne sont pas prises en considration. Par exemple, lassembleur traitera dans la mme faon .include et .include.
.386
Ces directives permettent de choisir le processeur cible. Elles dterminent ainsi comment doit tre analys le code qui le suivra. Lusage le plus frquent de ces directives est den crire une seule au dbut du programme source, en privilgiant le dernier processeur de la srie. Cette directive ninfluence pas le codage des mnmoniques, mais restreint lusage de certaines instructions. Par exemple, si la directive .386 est utilis, vous pourrez employer les instructions spcifiques du 80386. Par contre, soumettant lassemblage le mme code source, mais la directive .8086, il y aurait une erreur chacune des instructions spcifiques du 80386 ! Mais, si dans le mme code source vous mettez des instructions spcifiques au 80586, il y aura galement erreur car ces instructions ne sont supportes ni par le 8086, ni par le 80386 ! Ces directives permettent dassurer un contrle lors dassemblage descendant, cest dire de permettre le filtrage par rejet des instructions inexistantes sur danciens processeurs. Il y a en ralit deux formes presque identiques pour chaque modle de directive. .386/.386p .486/.486p Ces versions p sont ncessaires seulement quand votre programme emploie des instructions privilgies. Les instructions privilgies sont des instructions rserves par le systme du CPU / fonctionnement en mode protg.
.model flat, stdcall

.model est une directive d'assembleur a pour but de dterminer plusieurs caractristiques importante dans un programme : le type de mmoire, directive .model est la suivante : .model MemoryModel ModelOptions MemoryModel spcifie le type de mmoire de votre programme. Sous Win32, il y a seulement un type, le modle FLAT plat , vous vous souvenez ? On utilise un seul segment de 4 GB, bref, c'est une la convention dappel des fonctions. La syntaxe de la
Page 81
manire d'organiser la mmoire pour ne plus qu'il y ait de segments, et juste des adresses mmoire 32bits. ModelOptions signifie : appel standard, c'est--dire la faon dont sont transmis les paramtres la fonction, autrement l'ordre de passage des paramtres de la pile vers un Call, de gauche droite ou de droit gauche et aussi a quilibrera l'encadrement de la pile aprs l'appel de la fonction. La plate-forme Win32 emploie exclusivement STDCALL, les paramtres sont transmis de la droite vers la gauche car les APIs utilisent ce format. .data Cette section contient les donnes initialises de votre programme. Les variables que l'on donne une valeur ds le dpart.
.data? Cette section contient les donnes non initialises de votre programme. Parfois vous voulez juste prvoir un espace mmoire pour contenir de futurs donnes, mais ne voulez pas l'initialiser (lui donner une valeur initiale). C'est le but de cette section. L'avantage des donnes non initialises est que l'espace est allou quand le programme est charg dans la mmoire mais la taille de fichier sur le disque n'est pas augmente. .const Il arrive parfois que l'on ait besoin d'utiliser une variable dont on voudrait qu'elle garde la mme valeur pendant toute la dure du programme. C'est--dire qu'une fois dclare, vous voudriez que votre variable conserve sa valeur et que personne n'ait le droit de changer ce qu'elle contient. Ces variables particulires sont appeles constantes, justement parce que leur valeur reste constante. Vous n'tes pas forcment oblig d'employer ces trois sections dans votre programme. Dclarez seulement la (ou les) section (s) que vous voulez utiliser. Par contre, il n'y a seulement qu'une section pour le code : .code, cette section reprsente les instructions proprement-dites du programme. <label> end <label>
Page 82
O <label> reprsente n'importe quelle tiquette arbitraire, et est employ pour marquer le dbut et la fin de votre code. Les deux "label" doivent tre identiques. Toutes vos lignes de code doivent se trouver entre <label> et end <label>. Il remplace le main des langages C / C++. Rien de bien compliqu ! Mais il a le mrite d'tre compris aisment. Chapitre 5 : Lenvironnement Windows Contrairement DOS qui est un environnement mono-tche, mono-utilisateur par excellence, Windows depuis la version 95 est un vrai un systme d'exploitation graphique et multitche pouvant ainsi grer plusieurs "tches" simultanment. La programmation de logiciels sur cet OS ncessite donc quelques notions de l'API WIN32. L'interface de programmation Win32 (en anglais, Win32 Application
Programming Interface ou
Win32API) est commune aux systmes d'exploitation Windows 9x et Windows NT/2000. Les API Windows offrent aux programmeurs la possibilit d'interagir avec le systme d'exploitation. Elles offrent des possibilits presque infinies, et dpassent de trs loin les possibilits apportes par les environnements de dveloppement (Visual Basic, Windev, ...). Par exemple, elles vous permettront de contrler une application, d'accder au registre Windows, de jouer des sons, mais aussi l'ouverture de connections vers Internet, l'criture sur votre disque dur, sortir un beau listing sur votre imprimante Les API ne sont en fait que des fonctions semblables celles que vous pouvez crer dans votre environnement de dveloppement : en rgle gnrale, on leur fournit un certain nombre de paramtres, et elles renvoient quelque chose, ou ralisent une action prcise. Ces fonctions sont contenues dans des fichiers dll, tels "user32.dll", "kernel32.dll", ou bien d'autres encore. Les fonctions les plus couramment utilises sont celles qui constituent Microsoft Windows lui-mme. Ces procdures sont toutefois crites en langage C, et doivent donc tre dclares avant de pouvoir les utilises avec d'autres langages. Les API Windows sont plutt faciles utiliser, une fois que l'on connat leur dclaration et leurs paramtres. Leurs difficults sont autres : les problmes se posent gnralement lorsqu'on cherche l'API qui nous rendrait service, puisqu'on se trouve alors confront des milliers de fonctions aux noms pas toujours trs explicites. Lorsquenfin on a trouv celle qui convient, on dcouvre qu'on est incapable de l'utiliser, car on ne connat ni sa dclaration, ni ses paramtres, ni son utilisation ! Pour rsoudre ce problme, il n'y a pas cinquante solutions : la premire est de chercher des exemples utilisant cette API, la deuxime est dutiliser la MSDN Online sur le site de Microsoft (qui contient entre autres cette
Page 83
documentation), ou encore le fichier d'aide win32.hlp, disponible en tlchargement gratuitement. Ce fichier d'aide contient une description trs complte des APIs de Windows, des structures utiliser, etc. Les programmes Win se lient dynamiquement avec ces DLLs, c'est--dire : Les codes des fonctions API ne sont pas inclus dans le programme Win excutable. Dans votre programme, pendant son excution, pour accder l'API dsire, vous devez dclarer cette information dans le fichier excutable. L'information est dans une bibliothque d'importation. Vous devez lier vos programmes avec les bibliothques d'importation correctes sinon ils ne seront pas capables de retrouver la fonction de l'API souhaite. Quand un programme Win est charg dans la mmoire, Windows lit l'information stocke dans le programme. Cette information inclut les noms des fonctions et les DLLs o rsident ces fonctions. Ex : la DLL "User32.dll" contient la fonction MessageBox (ainsi qu'une multitude d'autres fonctions). L'information que cherchera Windows dans votre excutable ce sera quelque chose comme Call USER32 ! MessageBox . Ds que Windows tombera sur un tel renseignement dans votre programme, il chargera la DLL et excutera la fonction. Il y a deux catgories de fonctions API : les uns pour ANSI et les autres pour Unicode. Les noms des fonctions API pour ANSI sont suivis du suffixe "A", ex : MessageBoxA. Ceux pour Unicode ont le suffixe "W". Windows 95 traite naturellement ANSI, et Windows NT Unicode. D'habitude on se sert de la convention ANSI, qui pour l'ensemble des caractres proposs par votre ordinateur sont termins par le caractre NULL. ANSI reprsente chaque caractre sur 1 octet. Il est suffisant pour les langues europennes, mais il ne peut pas manipuler la plupart des langues orientales qui ont plusieurs milliers de caractres uniques. C'est pourquoi UNICODE entre en jeu. Un caractre UNICODE a une taille de 2 octets, ce qui lui permet d'avoir une srie de code de 65536 caractres uniques. Mais la plupart du temps, vous emploierez un fichier INCLUDE (*.inc) qui peut dterminer et choisir les fonctions API appropries votre plate-forme suivant ce que doit faire votre programme. Rfrez-vous juste aux noms de fonction API sans le suffixe. Traditionnellement, les tutoriaux pour la programmation, dont le but est de faire la dmonstration rapide d'un langage de programmation commence, avec une application qui affiche le message "Hello World" dans une console. La fentres d'interface graphique quivalente cela est la fonction MessageBox. Dans RadAsm pour, ouvrez un nouveau projet nomm MessageBox.
Page 84
Cliquez sur "Go" ou "CTRL + F5", puis coucou petite fentre, fait cheez la camra.
Maintenant nous allons analyser les nouvelles parties.
option casemap : none

.option est une directive dassemblage qui indique que la diffrence entre majuscule et minuscule est importante, ainsi par exemple, MessageBox et messagebox seront compltement diffrent. Notez la nouvelle directive, include. Cette directive est suivie par le nom du fichier que vous voulez insrer sa place. Dans cet exemple, quand Masm traite la ligne include windows.inc, Il ouvrira windows.inc qui se trouve dans le rpertoire C:\MASM32\include, comme tout les autres fichiers .inc dailleurs, et fera en sorte que son contenu (celui de windows.inc) soit coll dans votre programme win32. Il ne contient pas de prototype de fonction. windows.inc n'est en aucun cas complet (c'est comprhensif car on peut toujours y rajouter de nouvelles choses). windows.inc est un fichier matre,
Page 85
celui-ci contient toutes les dclarations de constante, les appels de fonctions, les structures de donnes Win32, il contient notamment : MB_OK NULL
Celles-ci peuvent tre utilises par leur nom pour amliorer la lisibilit de votre code source. T'es bien gentil, mais c'est quoi, un prototype de fonction ? Celle-ci appelle immdiatement une autre, cest quoi une fonction ? En programmation, on dsigne par une fonction un morceau de code qui sert faire quelque chose de prcis. Une fonction excute des actions et renvoie un rsultat. On dit qu'une fonction possde une entre et une sortie. Schmatiquement, a donne quelque chose comme a :
Je vous l'ai dit ds le tout dbut de ce chapitre du cours, et je ne vous ai pas menti : les APIs Windows sont aussi des fonctions. Ce sont en quelque sorte des fonctions toutes prtes qu'on utilise trs souvent. Ces fonctions ont t crites par des programmeurs avant vous, elles vous vitent d'avoir rinventer la roue chaque nouveau programme. Lorsqu'on appelle une fonction, il y a 3 tapes : 1. L'entre: on fait "rentrer" des informations dans la fonction (en lui donnant des informations avec lesquelles travailler), on appelle a, ses arguments ou ses paramtres. 2. Les calculs : grce aux informations qu'elle a reues en entre, la fonction travaille. 3. La sortie : une fois qu'elle a fini ses calculs, la fonction renvoie un rsultat. C'est ce qu'on appelle la sortie, ou encore le retour. Le prototype d'une fonction correspond simplement son en-tte. On place donc le prototype en dbut de programme (Si vous avez dj programm en C++, vous connaissez sans doute les prototypes de fonctions, qui sont utiliss dans les dclarations des classes). Cette description permet lassembleur de vrifier la validit de la fonction chaque fois qu'il la rencontre dans le programme, en lui indiquant : Le type de valeur renvoye par la fonction.
Page 86
Le nom de la fonction. Les types darguments.
Contrairement la dfinition de la fonction, le prototype n'est pas suivi du corps de la fonction (contenant les instructions excuter), et ne comprend pas le nom des paramtres (seulement leur type). Un prototype de fonction ressemble donc ceci : FunctionName PROTO [ParameterName]:DataType, [ParameterName]:DataType,... En rsum, la directive PROTO cre un prototype de procdure. Cest une sorte de pr-dclaration qui mentionne le nom de la procdure et la liste de ses paramtres. Grce un prototype, vous pouvez insrer des appels une procdure avant le corps de dfinition de cette procdure (Si vous avez dj programm en C++, vous connaissez sans doute les prototypes de fonctions, qui sont utiliss dans les dclarations de classes.). Le mot l proto est prcd du nom de la fonction puis suivi de la liste des paramtres, spars par des virgules. Dans l'exemple, ci-dessous, on dfinit ExitProcess comme une fonction qui prend seulement un seul paramtre de type DWORD.
includelib ne fonctionne pas comme include. C'est seulement une faon de dire Masm quelles
bibliothques d'importation sont employes par vos programmes. Quand Masm voit une directive includelib, il met une commande de linker dans le fichier d'objet pour que le linker sache avec quelles bibliothques d'importation votre programme a besoin de se lier. Vous n'tes pas forc d'employer includelib quoique. Vous pouvez spcifier les noms des bibliothques d'importation dans la ligne de commande du linker, mais croyez-moi, c'est ennuyeux et la ligne de commande ne peut contenir que 128 caractres. Le programme que nous avons entre les mains fait appel deux apis MessageBox et ExitProcess fessons partie respectivement aux librairies user32.lib et kernel32.lib, donc nous avons besoin d'inclure le prototype de fonction de user32.dll et kernel32.dll. Ces fichiers sont user32.inc et kernel32.inc. Si vous l'ouvrez avec un diteur de texte, vous verrez que c'est plein de prototypes de fonction. Si vous n'incluez pas kernel32.inc par exemple, vous pouvez toujours appeler ExitProcess, mais seulement avec la syntaxe d'appel simple (Push 0 puis Call ExitProcess). Vous ne serez pas capables d'invoker la fonction (ExitProcess). Humm, invoke ! Quest-ce qui se cache derrire cet obscur jargon ?
Page 87
Avec l'utilisation de la directive Masm invoke (High Level Syntax), les APIs Windows peuvent tre utiliss d'une manire trs similaire aux langages "C" ou Pascal
Ceci est la forme moins lisible de la mme fonction :
Permet non seulement de diminuer le nombre de lignes lors des appels de proc (push, push), mais aussi de vrifier automatiquement la syntaxe de l'appel. Le nombre de paramtres passs la fonction doit correspondre au nombre d'arguments attendus par la fonction. La taille des paramtres (dword, byte...) doit correspondre la taille des arguments attendus par le proc. Si une des deux conditions n'est pas remplie, il se produit une erreur lassemblage. Aucune de ces erreurs ne se produit lorsqu'on utilise les push suivis d'un call. La sanction de la non utilisation de invoke peut fort bien tre des heures et des heures de dbogage passs chercher les arguments manquant ou mal dimensionns (bonjour la galre s'il existe plus d'une centaine d'appels contrler, ce qui n'a rien d'norme). Par exemple, si vous faites :
Sans pousser un dword sur la pile (Push 0, avant d'appeler la fonction ExitProcess), l'assembler ne sera pas capable de comprendre cette erreur votre place. Vous vous en apercevrez plus tard quand votre programme plantera. Mais si vous employez :
Le linker vous informera que vous avez oubli de pousser un DWORD sur la pile vitant ainsi l'erreur. Je vous recommande donc d'employer invoke au lieu d'un simple 'Call'.
Une fois compil, le programme aura la mme taille que si on avait utilis la syntaxe de haut niveau de Masm.
Page 88
Pour des problmes plus complexes, nous obtenons ainsi de longues listes d'instructions, peu structures et par consquent peu comprhensibles. En plus, il faut souvent rpter les mmes suites de commandes dans le code source, ce qui entrane un gaspillage de mmoire interne et externe. Vous pouvez ainsi crer des prototypes de fonction pour vos propres fonctions. Nous verrons a dans les chapitres suivants. Si vous tes intress par la programmation oriente objet, pensez toutes les fonctions dune mme classe. Cest peu prs lquivalent dune collection de procdures et de donnes dfinis dans le mme module de code source assembleur. Rappelons que le langage assembleur t cre bien avant la programmation oriente objet. Il ne peut donc pas proposer une structure formelle du niveau du celle du C++ ou de Java. Cest vous dimposer un peu de rigueur dans la structure de rdaction de vos programmes.
Chapitre 6 : Structure de donnes Les variables et les constantes Pour fonctionner, un programme gnralement besoin de pouvoir utiliser des donnes. Pour cela, il doit pouvoir stocker les valeurs, et pouvoir y accder par la suite. Le programme pourra ensuite les contrler, et pourquoi pas, les modifier. Pour cela, il existe un moyen simple qui est l'utilisation des variables. Il y a toutes sortes de choses que lon peut stocker au sein de variables : les informations concernant un employ, la longueur dun morceau de musique, le nombre de bicyclettes commandes aujourdhui, etc. La variable est un concept important en programmation informatique. Intuitivement, il s'agit d'un nom qui se rfre une chose. Informatiquement, c'est une rfrence une adresse mmoire. Il s'agit donc
Page 89
d'une entit cre dans l'ordinateur laquelle on donne un nom et qu'on utilise en voquant ce nom dans le code source du programme, capable de contenir des informations dont la valeur peut varier au cours du temps selon les manipulations que le programme lui fait subir. Les dclarations introduisent les variables qui sont utilises, fixent leur type et parfois aussi leur valeur de dpart. Les oprateurs contrlent les actions que subissent les valeurs des donnes. Pour produire de nouvelles valeurs, les variables et les constantes peuvent tre combines l'aide des oprateurs dans des expressions. Les variables peuvent tre trs utiles si vous navez pas suffisamment de registres. Par exemple, le nom NombreDeChansons vous permet de savoir tout de suite que cette variable reprsente le nombre de chansons couter dans le juke-box. En revanche, C3PO nest pas un nom gnial pour une variable. Ce peut tre un numro de srie, un nom de robot ou qui sait quoi. Masm dfinit plusieurs types de donnes intrinsques. Chaque type permet dexploiter un ensemble de valeurs et de les affecter des variables et des expressions du mme type. Par exemple, une variable de type intrinsque DWORD permet de stocker nimporte quelle valeur entire sur 32 bits. Il existe des types plus contraignants, et notamment REAL4, qui ne peuvent accepter quune constante numrique relle. Limage si dessous prsente tous les types de donnes pour les valeurs entires, except les trois dernires. Pour celle-ci, la notation IEEE correspond au standard des formats de nombres rels ( virgule flottante) tels que publies par lassociation scientifique IEEE Computer society.
Les directives BYTE, WORD, DWORD, FWORD, QWORD, TBYTE servent dfinir des emplacements de donnes, vous pouvez encore utiliser les directives DB (Define BYTE), DW (Define WORD), DD (Define DWORD), DF (Define FWORD), DQ (Define QWORD), et DT (Define TBYTE) pour dclarer vos variables.
Page 90
Pour laisser une variable sans valeur initiale (non nationalis), il suffit dindiquer pour linitialiser le point dinterrogation. Il en rsultera que la variable recevra une valeur lors de lexcution.
En informatique, les rationnels sont souvent appels des flottants . Ce terme vient de en virgule flottante et trouve sa racine dans la notation traditionnelle des rationnels. La directive REAL4 permet de rserver un espace pour une variable relle sur 4 octets simple prcision. La directive REAL8 dfinit un rel double prcision sur 8 octets, et la directive REAL10 dfinie un rel prcision tendue sur 10 octets. Chaque directive suppose la mention dun initialiseur constant rel dont la largeur correspondant :
Pour dclarer une donne de type chane (un nom programmatiquement correct pour dsigner du texte), vous devez dlimiter les caractres qui la constituent au moyen dapostrophes ou des guillemets. Les chanes les plus rpandues en programmation se terminent par un octet dont la valeur est 0. Ces chanes sont appeles chanes zro terminal, ou chanes AZT. Elles sont trs utilises dans les langages C, C++ et Java, et par les fonctions de Windows. A chaque caractre correspond un octet de stockage. Les chanes constituent une exception la rgle qui veut que les valeurs de type octet soient spares les unes des autres par des virgules. Si cette exception nexistait pas, la variable dans le code source aurait d tre dfinie comme ceci :
Ce qui serait vite fatiguant. Vous pouvez distribuer une chaine de caractres en plusieurs lignes sans tre forc de rpter le label au dbut de chaque ligne, comme le montre cet exemple :
Hourra !
Page 91
Rappelons que les octets possdant les valeurs dcimales 0Dh (13d) et 0Ah (10d) correspondent au couple Retour chariot/Saut de ligne (CR/LF) qui permettent de marquer la fin dune ligne de texte. Lorsque ces deux caractres sont envoy pour affichage, il provoque le renvoie du curseur dans la premire colonne de la ligne suivante. Le caractre dextension de la ligne Masm est la barre oblique inverse \ . Il permet de tronquer visuellement une ligne qui reste au niveau logique. Le symbole \ ne peut donc tre plac qu la fin dune ligne. Au niveau du programme assembleur, les deux instructions suivantes sont absolument identiques :
Porte des variables La porte d'une variable dsigne la zone du code dans laquelle la variable sera connue et donc utilisable. On distingue deux portes diffrentes : Une porte locale une fonction. Une porte globale un programme.
Si vous dclarez une variable ou une constante en dehors d'une dfinition de fonction (dans la section .data, data?, ou .const), il s'agit d'une variable globales statiques. Le terme statique signifie que la dure de vie de la variable est gale celle de lexcution du programme. Le terme global signifie que la valeur de la variable est accessible et modifiable dans tout le programme. En revanche, si vous dclarez une variable au sein d'une dfinition de fonction, il s'agit d'une variable locale. Elle est cre et dtruite chaque fois que la fonction est excute ; il est impossible d'y accder en dehors de la fonction. Sa dure de vie est donc bien infrieure la dure dexcution du programme. Attention : les variables
Page 92
locales ne peuvent tre dclares qu'en tte de la fonction. Vous connaissez sans doute dj les variables locales si vous avez programm avec un langage de haut niveau. Voyons comment exploiter les variables locales en assembleur. Rappelons dabord les avantages du local par rapport au global : Laccs limit une variable local simplifie le dbogage, car les origines ventuelles dun disfonctionnement sont moins nombreuses. Une variable local utilise la mmoire de manire efficace, en loccurrence uniquement pendant lexcution de la routine dans laquelle elle est dclare. Cela permet de rutiliser lespace pour de nouvelles variables locales. Une variable locale peut porter le mme nom qu'une variable globale, mais elle n'en reste pas moins distincte. En consquence, si vous modifiez la valeur d'une variable, cela n'a aucun effet sur l'autre. Au sein de la fonction dans laquelle la variable locale est dclare, seule la version locale est significative. Ce concept porte le nom de visibilit. Les variables locales sont cres sur la pile dexcution. Vous ne pouvez pas leur donner de valeur initiale lors de lassemblage, mais vous tes libres dcrire une valeur initiale en dbut dexcution. La directive LOCAL La directive LOCAL dclare une ou plusieurs variables locales dans une procdure. Elle doit tre mentionne sur la ligne qui suit immdiatement celle qui constitue louverture du bloc de dfinition dune procdure. Elle doit tre introduite par la directive PROC. Voici sa syntaxe formelle : LOCAL ListeVar ListeVar correspond une liste de noms de variables spars par des virgules et pouvant stendre sur plusieurs lignes. Chaque dfinition de variable respecte la syntaxe suivante : Label : type Label doit tre un identificateur autoris et type doit tre un des types standard WORD, DWORD, etc. ou un type dfini par le programmeur. (Nous aborderons les structures de donnes et les types dfinis par le programmeur directement aprs ce paragraphe). La directive LOCAL alloue de la mmoire sur la pile pour des variables locales employes par la fonction. La totalit des directives LOCALES doivent tre places juste au-dessous de la directive PROC. Les variables locales ne peuvent pas tre employes l'extrieur de la fonction, elles sont crs et seront automatiquement dtruites quand la fonction retourne l'appel. Un autre inconvnient est que
Page 93
vous ne pouvez pas initialiser des variables locales automatiquement parce qu'elles sont uniquement alloues dans la mmoire de la pile au moment seulement o la fonction est entre. Exemple : La procdure TriABulle dclare la variable local temp de taille double-mot (dword) et la variable SwapFlag de taille BYTE :
On a appris que pour dclarer un prototype de procdure on utilise la directive PROTO, maintenant on va voir comment dclarer la procdure elle-mme en utilisant la directive PROC. Au niveau lmentaire, une procdure est un bloc contigu dinstructions portant un nom et se terminant par une instruction de retour dexcution. Vous dclarer une procdure avec le couple de directives PROC et ENDP. La directive PROC est essentielle : Elle peut comporter une liste de paramtres, comme le montre sa syntaxe formelle simplifie :
Vous devez indiquer comme dernire instruction celle de retour RET. Elle oblige le processeur poursuivre lexcution linstruction qui suit celle qui a constitu lappel au sous-programme. Les paramtres peuvent tre placs sur une seule ligne :
Chaque paramtre doit obir la syntaxe suivante : Nomparam: type Nomparam est un nom choisi par le programmeur. Le paramtre est accessible uniquement dans la procdure courante (porte locale). Vous pouvez donc utiliser le mme nom de paramtre dans plusieurs procdures, condition que a soit ni variable globale, ni un label de code. Pour le type, choisissez lun des mots rservs suivants : BYTE, SBYTE, WORD, SWORD, DWORD, SDWORD,
Page 94
FWORD, QWORD ou TBYTE, ou indiquez un type qualifi, qui peut tre un pointeur sur lun des types existants. Voici quelques exemples de types qualifis PTR BYTE, PTR WORD, Voyons quelques dfinitions de procdure avec diffrents types de paramtres. Ne vous souciez pas du corps de la fonction pour linstant. Exemple 1 La procdure suivante attend en entre deux valeurs de taille double-mot :
Exemple 2 La procdure suivante attend un pointeur sur un octet :
Exemple 3 La procdure suivante attend deux pointeurs sur des doubles-mots :
Exemple 4 La procdure suivante attend le pointeur sur un octet pTampon. Elle dclare localement la variable fileHandle :
Page 95
La directive ALIGN La directive ALIGN permet daligner une variable sur une frontire doctet, de mot, de double-mot ou de paragraphe. Voici sa syntaxe : ALIGN frontiere frontiere peut tre gale 1, 2 ou 4. Si elle vaut 1, la prochaine variable est aligne sur une frontire doctet (valeur par dfaut). Si la valeur est 2, la variable est aligne sur la prochaine adresse paire. Si la frontire vaut 4, la prochaine variable est stocke la prochaine adresse multiple de 4 en partant du dbut du segment. Pour assurer ce recadrage, lassembleur insre des octets vides avant la variable. Vous pouvez vous demander quoi sert cet alignement. Cest parce que le processeur peut lire et crire plus rapidement des objets stocks des adresses paires. Prenons lexemple suivant. Nous savons que bVal est automatiquement stock une adresse offset paire. Si nous ajoutons ALIGN 2 avant la directive wVal, cette variable sera place un dcalage pair elle aussi. Nous allons par exemple choisir dimplanter la premire variable ladresse 00404000 :
Si dVal avait t place loffset 00404005, la directive ALIGN 4 laurait repousse jusqu loffset 00404008. Directive dgalit (=) La directive symbolis par le signe = permet dassocier un nom de symbole une expression numrique entire. Voici sa syntaxe gnrique : nom = expression
Page 96
Normalement, expression est une valeur entire sur 32 bits. Lors de lassemblage du programme, toutes les occurrences de nom sont remplaces par expression dans une premire tape de prtraitement. Par exemple, lorsque lassembleur rencontre les deux lignes suivantes :
Il gnre une seule instruction machine :
Dans lexemple prcdant, nous aurions pu viter de dfinir le symbole COMPTEUR, et ajouter directement la valeur littrale 100 dans linstruction MOV. Lexprience montre que lutilisation de symboles rend les programmes plus simples lire et maintenir. Imaginez que COMPTEUR soit utilis dix fois dans le mme programme. Si vous avez besoin plus tard de modifier la valeur de COMPTEUR en 200, vous navez quune seule ligne modifier :
Lorsque vous rassemblez le programme, tous les occurrences du symbole COMPTEUR sont automatiquement remplaces par la valeur 200. Si ce symbole navait pas t dfini, il aurait fallu modifier dix fois la valeur, au risque den oublier une. Cela provoquerait certainement un bogue. Loprateur PTR Loprateur PTR permet de passer outre la taille dclare lorigine pour un oprande. Vous nen aurez besoin que lorsque vous devrez accder une variable avec un attribut de taille diffrent de celui utilis lors de la dclaration de cette variable. Par exemple, supposons que nous ayons besoin de copier les 16 bits de poids faible dune variable de taille double-mot appele monDouble dans le registre AX. Le programme assembleur refuse la copie suivante, car les tailles des deux oprandes ne correspondent pas :
Si nous insrons la mention WORD PTR, nous pouvons copier le mot de poids faible (5678h) dans AX :
Page 97
Pourquoi nest ce pas 1245h qui a t copi dans AX ? La cause en est lordre de stockage little
endian dont nous avons parl prcdemment. Dans la figure qui suit, la structure du stockage mmoire
de monDouble est prsente de trois manires : tout dabord en tant que double-mot, puis sous la forme de deux mots distincts (1234h), et enfin sous la forme de deux mots distincts (1234h), et enfin sous la forme de quatre octets distincts (78h, 56h, 34h, 12h) ;
Le processeur peut accder la mmoire selon nimporte laquelle des trois approches, quelle que soit la manire dont la variable a t dclare lorigine. Par exemple, si monDouble est situ loffset 0000, la valeur sur16 bits stocke cette adresse est 5678h. Pour lire le mot suivant, 1234h, il faut utiliser la mention monDouble+2, comme ceci :
Nous pouvons utiliser loprateur BYTE PTR pour rcuprer un seul octet de monDouble vers BL, par exemple :
Vous avez remarqu que PTR doit toujours tre combin avec lun des noms de types de donnes standard : BYTE, SBYTE, WORD, SWORD, DOWRD, SDWORD, FWORD, QWORD ou TBYTE. Copie dune petite valeur dans une grande Supposons que nous ayons besoin de copier deux valeurs de petite largeur vers un oprande de grande taille. Dans notre exemple, le premier mot est copi dans la partie basse dEAX, et le second dans la partie haute. Cela nest pas possible que grce loprateur DWORD PTR :
Page 98
Loprateur TYPE Loprateur TYPE permet de connatre la taille, en octets, dun lment isol dune variable complexe ou dune variable simple. Par exemple, TYPE appliqu un octet renvoie 1 ; appliqu un mot, il renvoie 2 ; appliqu un double-mot, il renvoie 4 ; et appliqu un quadruple-mot, il renvoie 8. Voici des exemples :
Les tableaux Les tableaux sont certainement les variables structures les plus populaires. Ils sont disponibles dans tous les langages de programmation et servent rsoudre une multitude de problmes. Imaginons que dans un programme, nous ayons besoin simultanment de 12 valeurs (par exemple, des notes pour calculer une moyenne). Evidemment, la seule solution dont nous disposons lheure actuelle consiste dclarer douze variables, appeles par exemple Notea, Noteb, Notec, etc. Bien sr, on peut opter pour une notation un peu simplifie, par exemple N1, N2, N3, etc. Mais cela ne change pas fondamentalement notre problme, car arriv au calcul, et aprs une succession de douze instructions Lire en algorithme distinctes. Cest tout de mme bigrement laborieux. Et pour un peu que nous soyons dans un programme de gestion avec quelques centaines ou quelques milliers de valeurs traiter, alors l cest le suicide direct. Cest pourquoi la programmation nous permet de rassembler toutes ces variables en une seule, au sein de laquelle chaque valeur sera dsigne par un numro. En bon franais, cela donnerait donc quelque chose du genre la note numro 1 , la note numro 2 , la note numro 8 . Cest largement plus pratique, vous vous en doutez. Un ensemble de valeurs portant le mme nom de variable et repres par un nombre, sappelle un tableau, ou encore une variable indice. Le nombre qui, au sein dun tableau, sert reprer chaque valeur sappelle surprise lindice. Chaque fois que lon doit dsigner un lment du tableau, on fait figurer le nom du tableau, suivi de lindice de llment, entre parenthses. Comme dit ci-dessus, un tableau est une collection squentielle de variables, toutes de la mme taille et de mme type, appeles des lments. Vous pouvez avoir accs tous les lments dans un tableau autant qu'au premier
Page 99
lment. Tandis qu'un tableau est identifi d'un nom, chaque lment dans un tableau en fait rfrence avec un nombre d'indice, commenant par le zro. L'indice de tableau apparat entre parenthses carr aprs le nom. Par exemple, dfinissant un tableau d'octets a appel "Tab":
Donne une valeur de 1 Tab [0], une valeur de 3 Tab [1], et ainsi de suite. Cependant, dans des tableaux avec des lments plus grands que 1 octet, les nombres d'indice (sauf le zro) ne correspondent pas la position d'un lment. Vous devez multiplier la position d'un lment de sa taille pour dterminer l'indice de l'lment. Ainsi, pour le tableau
Tab [4] reprsente le troisime lment (5), qui est de 4 octets depuis le dbut du tableau. De mme l'expression Tab [6] reprsente le quatrime lment (7) et Tab [10] reprsente le sixime lment (13). Si vous devez dclarer un grand tableau, vous pouvez utiliser l'oprateur DUP, par exemple :
Qui est quivalent crire :
Plus encore :
Qui est quivalent crire :
A noter qune chaine de caractre est aussi un tableau de caractres qui prend 1 octet de mmoire pour chaque caractre. Loprateur LENGTHOF
Page 100
Loprateur LENGTHOF permet de compter le nombre dlments dun tableau, partir des valeurs indiqus sur la mme ligne que le label. Comme exemple, nous allons dfinir les donnes suivantes :
Le tableau suivant prsente les valeurs qui sont renvoyes par chacune des expressions LENGHTOF. Expression LENGTHOF octet1 LENGTHOF tab1 LENGTHOF tab2 LENGTHOF tab3 LENGTHOF digitSt Valeur 3 30 + 2 5*3 4 9
Remarquez que lorsque nous utilisons des oprateurs de duplication DUP imbriqus dans une dfinition de tableau, LENGTHF envoie le produit des deux compteurs dlments. LENGHTOF est "myope" : lorsque vous dclarez un tableau sur plusieurs lignes sources, LENGHTOF ne voit que les donnes de la premire ligne. Dans lexemple suivant, la mention LENGHTOF monTablo renvoie la valeur 5 :
Pour pallier cette myopie, vous pouvez terminer la premire ligne par une virgule et poursuivre la liste des valeurs sur la ligne suivante. Dans lexemple suivant, LENTGHOF monTablo renvoie la valeur 10 :
Les structures Jusqu prsent, vous avez dcouvert les types de donnes simples et vous avez vu que lon peut stocker une information dans une variable. Mais supposons que vous dsirez stocker quelque chose de plus complexe quun simple type de donne : par exemple, le nom de lutilisateur, son adresse et son numro de tlphone.
Page 101
Vous pouvez certes le faire en stockant ces informations dans trois variables spares : une pour le nom, une autre pour ladresse, et une autre pour le numro de tlphone. Nanmoins, il y a plus pratique : dans la vie, il est naturel de regrouper les choses. Par exemple, vous dsirez lire ou imprimer lenregistrement concernant un employ. Bien que cet enregistrement comporte de nombreux lments (nom, adresse, numro de tlphone, salaire, etc.), vous le pensez probablement comme une entit complte. Il est dailleurs bien plus facile de dire : imprimer lenregistrement de lemploy que de dire imprimer le nom, ladresse, le numro de tlphone, le salaire , etc. Le groupement dun ensemble de variables apparentes en une seule entit est appel structure. Les structures sont une caractristique trs puissante de Masm32, et facilit lorganisation et le traitement des informations. Pour dclarer une structure, utilisez le couple de directives STRUCT prcd par le nom de la structure et ENDS. Par exemple :
Dfinissez ensuite la variable (un cas de la structure de Date appele "Lundi") l'un ou l'autre avec des donnes non initialises .data? :
Ou avec des donnes initialises :
Ou encore :
Finalement vous pouvez avoir accs la structure et ses champs directement du nom comme cela :
Ou indirectement via un indicateur comme cela :
Page 102
Les Unions Dans une structure, les donnes membres sont places de manire contige en mmoire. Supposons que dans notre ordinateur, un BYTE prenne un octet, un WORD en prenne 2 et un DWORD en prenne 4. Dfinissons alors notre struct comme ceci :
Voici alors le schma de sa rpartition en mmoire : X Y Z
Elle occupe donc en mmoire la somme des tailles de ses membres. D'ailleurs, vous pouvez avoir la taille de votre struct avec l'oprateur sizeof. Il existe un autre type de structure de donnes, appel union. Une union se comporte extrieurement de manire trs similaire la struct, mis part qu'elle ne peut tre passe comme argument une fonction. En matire de syntaxe et d'accs aux donnes membres, rien ne change. Ce qui change, c'est la rpartition en mmoire et les consquences qui en dcoulent quant l'utilisation des membres.
Voici notre premier exemple d'union :
Vous constatez qu'il n'y a pas grand chose qui change. Par contre, voici sa rpartition en mmoire : x y z
Page 103
Les trois membres commencent tous la mme case! Donc la taille de l'union est gale la taille du membre le plus grand. Le rle principal de l'union est d'conomiser de l'espace en mmoire. En effet, au lieu de mettre les membres bout bout en mmoire, vous les superposez, si bien que vous pourriez utiliser 50 DWORD dans une fonction sans prendre plus de 4 octets en mmoire. Cependant, si c'tait aussi simple que a, on ne travaillerait qu'avec des unions. En fait, il y a une contrainte : on ne peut travailler qu'avec un seul membre la fois. Je m'explique. Du fait de cette superposition, vous ne pouvez charger qu'un seul type la fois. Si vous effectuez une affectation l'un, les valeurs des autres membres ne sont plus retenues... ce n'est ni facile expliquer, ni facile comprendre. Un bon moyen de retenir ce qui se passe, c'est de se dire qu'une union est comme un ensemble de variables que vous ne pouvez jamais utiliser en mme temps : l'utilisation de l'une de ces variables provoque la "disparition" de toutes les autres, jusqu' ce que vous r-effectuiez une affectation avec une autre. Je vous ai prsent ici les unions car elles existent. Cependant, je crois bien que je n'en ai utilis quun nombre limit de fois dans ma vie, et tenter de les utiliser en pensant conomiser de la mmoire, c'est se compliquer la vie pour rien. Tout ce qu'il vous faut savoir, c'est qu'elles existent, histoire que vous ne soyez pas compltement dboussols si vous en croisez une dans un programme. Les pointeurs Tout le monde sait en gros ce qu'est un pointeur, mais parfois certaines ambiguts persistent et je prfre rendre les choses claires ds le dbut. Avant de voir la notion de pointeur sur une variable, peut-tre serait-il utile de bien se souvenir de ce qu'est une variable, justement. Alors une variable, c'est un emplacement quelque part en mmoire qui sert stocker des valeurs ou des objets (ou des pommes, des poires). Il faut viter de confondre le contenant, ou conteneur (la variable) du contenu (la pomme). Si je dis a, c'est parce que souvent la syntaxe mme du langage les confond. En algorithme Var : c, d en entier c <- 4 d <- c La premire affectation place 4 (la pomme) dans c (le contenant). La seconde affectation copie le contenu de c dans le contenant de d. Ca n'est pas du tout la mme chose ! Aprs la deuxime
Page 104
affectation, d contient 4, pas c. Et quand je dis pas c , a n'est ni c la valeur , ni c la variable : si je modifie c aprs-coup, d contient toujours 4. Je ne vous prends pas pour un idiot en vous expliquant tout a : ici c'est totalement vident, mais vous verrez qu'un peu plus tard a va le devenir soudainement beaucoup moins, alors autant tre clair ds le dbut. Donc, prsent que nous faisons bien la distinction entre le contenant et le contenu, et que nous savons qu'une affectation depuis une autre variable ne fait que copier le contenu d'une variable vers l'autre variable, intressons-nous aux pointeurs proprement dits. On se rappelle que la mmoire, c'est une suite d'octets, et que chaque octet peut tre numrot par un nombre allant de 0 beaucoup. Du coup, une variable (le conteneur) peut tre dsigne par l'indice du premier octet o se trouve ce conteneur, si l'on suppose que le conteneur se trouve plac d'une manire continue en mmoire, ce qui sera toujours le cas. C'est ce qu'on appelle l'adresse de la variable. Une adresse dsigne donc le conteneur qu'est une variable. Un pointeur, c'est une variable dont le contenu est une adresse. Donc, c'est une variable dont le contenu dsigne une autre variable. J'insiste sur le fait que c'est le contenu du pointeur qui dsigne cette seconde variable, et pas le pointeur lui-mme. Les oprateurs ADDR & OFFSET L'OFFSET renvoie l'adresse d'une variable. Il est utilis pour spcifier la localisation plutt que le contenu de la variable:
L'OFFSET peut aussi passer l'adresse d'une variable une fonction en invoquant une instruction. Cependant, a fonctionnera seulement pour des variables globales dclares. Cela chouera avec des variables. Ceux-ci n'ont aucune compensation comme ils sont crs sur la pile au moment de l'excution. . L'oprateur ADDR rsout ce problme. Il est utilis exclusivement avec invoke pour passer l'adresse d'une variable une fonction. Pour des variables globales il rsume une simple instruction PUSH, pareil que si l'OFFSET avait t utilise :
Page 105
Loprateur ADDR transmet un pointeur lors de lappel une procdure avec INVOKE. La valeur de ce pointeur est une adresse qui dsigne un emplacement mmoire, ce qui correspond au passage de paramtre par rfrence et non par valeur. C'est valable seulement dans le contexte de la directive INVOKE. Vous ne pouvez pas l'employer pour assigner l'adresse d'une donne un registre ou une variable, par exemple. Vous devez employer OFFSET au lieu dADDR dans ce cas. Cependant, il y a quelques diffrences entre les deux : ADDR ne peut pas manipuler l'avance la rfrence tandis qu'offset le peut. Par exemple, si la ligne o est rendu le programme, invoke un label qui est dfini quelque part plus loin dans le code source, ADDR ne marchera pas.
MASM indiquera une erreur. Si vous utilisez OFFSET au lieu dADDR dans ce petit bout de code, alors MASM l'assemblera avec succs. ADDR peut manipuler des variables locales tandis quOFFSET ne le peut pas. Une variable locale est seulement un petit espace rserv sur la pile. Vous ne connatrez seulement son adresse que le temps de l'excution. OFFSET est interprt pendant le droulement du programme par l'assembleur. Donc il est naturel qu'OFFSET ne travaille pas avec des variables locales. ADDR est capable de manipuler des variables locales grce au fait que l'assembleur vrifie d'abord si la variable mentionne par ADDR est globale ou locale. Si c'est une variable globale, il met l'adresse de cette variable dans le fichier d'objet. cet gard, il travaille comme offset. Si c'est une variable locale, il produit un ordre d'instruction qu'il appelle en ralit avant la fonction :
Puisque LEA peut dterminer l'adresse d'un label pendant l'excution, a fonctionne trs bien. Les crochets
Page 106
Les crochets indiquent gnralement la valeur (le contenu) d'une variable par opposition son adresse. Cependant, la syntaxe MASM diffre lgrement celle d'autres assembleurs cet gard. Dans MASM tous ceux-ci produisent la mme instruction:
MaVariable et [MaVariable] les deux signifient la valeur de MaVariable. Beaucoup de programmeurs utilisent par habitude des crochets avec des variables pour dnoter le contenu ainsi cela rend le code source un peu plus lisible et il le rend plus facile au code d'tre support par d'autres assembleurs. Comme il a t dit ci-dessus, l' offset MaVariable & addr MaVariable les deux signifient l'adresse de MaVariable. Quand c'est utilis avec les registres, cependant, les crochets font vraiment la diffrence et ont tendance pointer l'adresse mmoire :
La fonction MessageBox Faites sortir votre rfrence dAPIs (le fichier Win32.hlp), sinon, lMSDN est mise votre disposition. On constate alors que lAPI MessageBox prend 4 paramtres comme nous le voyons.
Page 107
La fonction MessageBox sert gnralement afficher un petit message l'utilisateur comme pour l'informer du succs ou de l'chec d'une opration par exemple ou pour demander une action effectuer lorsque le programme ne peut prendre de dcision tout seul. Donc la solution la plus simple pour afficher du texte depuis un programme graphique consiste la placer dans une bote de message qui, une fois ouverte, attend que lutilisateur clique un bouton. hWnd est le handle ou la poigne de la fentre parente. Vous pouvez vous imaginer qu'un Handle est un numro qui reprsente la fentre laquelle vous fates rfrence. Sa valeur n'a pas d'importante pour vous. Vous vous rappelez seulement qu'il reprsente la fentre. Quand vous voulez faire quelque chose avec la fentre, vous devez vous y rfrer par son 'handle' ou tout simplement NULL si on ne veut lui associer aucune fentre. En ce qui concerne les deux paramtres suivants de type texte, aucun problme. lpText pointe sur une chane zro terminal afficher dans la bote, lpCaption pointe sur une chane zro terminal qui sert de titre la bote. uType, le rle de cet argument est double : il doit indiquer d'une part quel est le jeu de boutons souhait, parmi celle qui sont six disponibles. Il doit galement stipuler quelle illustration viendra ventuellement gayer votre bote messages, parmi les quatre possibles (Critical, Exclamation, Information, Question). Il est possible d'activer de surcrot quelques autres options, mais nous les laisserons de ct provisoirement. Ce qui compte, c'est de comprendre comment a marche. Il a y d'autres styles de boutons comme ci-dessous
Page 108
Ceux-ci affichent un style d'icne:
Et le bouton qui est slectionn par dfaut :
Le contrle de ces constantes est dfini dans le fichier windows.inc qui peut aussi tre ouvert dans RadAsm comme indiqu ci-dessous:
Page 109
Plusieurs constantes peuvent tre combines en un paramtre pour une fonction en les sparant avec "or" ou "+". Par exemple Modifier le code en:
Ca vous donnera une fentre comme ci-dessous:
Chapitre 6 : Principe de base de la programmation Windows Pour se lancer dans le dveloppement dapplications pour Windows, il est indispensable de bien connatre les spcificits de la programmation sous Windows, qui se distingue nettement de la programmation traditionnelle. La programmation Windows passe obligatoirement par lAPI Win32, qui rassemble tous les types de donnes et les fonctions qui sutilisent pour crer des programmes
Page 110
Windows. LAPI Win32 est importante, et il faut consentir quelques efforts pour se sentir laise avec ses nombreuses facettes. Certains aspects de la programmation Win32 sont communs tous les programmes Windows quil sagisse dun traitement de texte ou dun jeu. Ce sont surtout ces caractristiques communes qui sont exposes dans ce chapitre. Une fois que vous laurez lu et assimil, vous aurez des bases solides qui vous permettront dacqurir des connaissances valables pour toute sorte de programme. Programmation vnementielle Un des aspects les plus droutants de la programmation Windows pour les dbutants est la nature vnementielle de cette programmation, plus simplement vnementielle signifie que les programmes Windows rependent leur environnement. Le flux du programme est dirig par les vnements externes au programme, comme des clics de souris et des frappes au clavier. Au lieu dcrire du code dtectant les frappes du clavier, le programmeur Windows crit du code qui accomplit une action chaque fois quune frappe au clavier est rapporte au programme. Au fur et mesure que vous vous familiarisez avec le concept dvnements, vous pouvez constater que toute modification de lenvironnement peut dclencher un vnement. Vous pouvez ainsi concevoir et crire vos programmes de manires quils ignorent ou ragissent des vnements spcifiques. La nature vnementielle de Windows a beaucoup voir avec le fait que Windows est un systme dexploitation graphique. Windows a fort faire et effectue un traitement trs complexe pour permettre plusieurs programmes dtre excuts simultanment et de partager le mme espace lcran, de la mmoire, des priphriques dentre et, virtuellement, toute autre ressource systme. Lapproche vnementielle de la gestion des interactions avec lutilisateur et des modifications systme est pour beaucoup dans la flexibilit et la puissance de Windows. Dans le contexte de la programmation dapplications, lapproche vnementielle permet de dcomposer les tches en fonction des vnements qui se produisent. En dautres termes, un clic avec le bouton gauche de la souris, avec le bouton droit de la souris, une criture dans une zone de texte, un choix dans une case d'option ou une case cocher, le dplacement d'un objet et une frappe au clavier sont traits comme des vnements distincts.
Communication par le biais de messages Dans les programmes non graphiques traditionnels, le programme invoque une fonction systme pour accomplir une tche donne. Dans les programmes Windows graphiques, ce scnario est pouss plus avant, puisque Windows peut invoquer une fonction du programme. En effet, Windows peut envoyer un
Page 111
message au programme, dans lequel sont contenues des informations relatives un vnement. Il
envoie des messages chaque fois que se produit quelque chose dont un programme souhaite tre inform, comme le glissement de la souris ou le redimensionnement de la fentre principale du programme par lutilisateur. Les messages sont adresss une fentre spcifique, qui est gnralement la fentre principale. Dans une session Windows, plusieurs fentres cohabitent gnralement lcran, et chaque fentre reoit du temps autre des messages informant des changements survenus. A chacune de ces fentres est associe une procdure de fentre, qui est une fonction spciale charge de traitement des messages envoyes par le systme dexploitation la fentre. Windows se charge dadresser les messages aux procdures de fentre appropries. Il appartient au programmeur dcrire le code de la procdure de fentre pour que le programme rponde certains messages. La notion dindpendance vis--vis des priphriques A lge dor des jeux vido par exemple, les dveloppeurs de jeux crivaient souvent leurs programmes dune manire telle quils utilisaient directement la mmoire de la carte graphique. Cette technique rendait lexcution des jeux extrmement rapide, parce que les images des jeux taient directement traites par la carte graphique. Windows noffre pas cette possibilit. De manire gnrale, Windows a t volontairement conu pour empcher les utilisateurs dinteragir directement avec les composantes de lordinateur, comme la carte graphique. De ce fait, les applications Windows sont dites indpendantes
vis--vis des priphriques, cest--dire quelles dessinent les images de manire indpendante des
priphriques utiliss cette fin. Lintrt de cette approche rside dans le fait que les applications Windows peuvent fonctionner avec une vaste gamme de matriel sans aucune modification particulire. Une telle compatibilit tait impensable dans lunivers DOS. Lindpendance vis--vis de priphriques sous Windows est rendue possible par linterface de priphrique graphique, ou GDI (Graphical Device Interface), qui est la partie de lAPI Win32 qui gre laspect graphique. Linterface GDI intervient entre le programme et le matriel graphique physique. Au niveau du GDI, les images sont dessines sur un priphrique virtuel de sortie. Cest ensuite Windows quil appartient doprer la transition entre le priphrique de sortie virtuel et un priphrique rel spcifique, via la configuration systme, les pilotes des priphriques et ainsi de suite. Bine que linterface GDI a t expressment conue pour vous garder distance du matriel graphique, elle reste trs performante. En fait, toutes les applications prsentes dans ce guide sont uniquement fondes sur cette interface. Stockage des informations des programmes sous forme de ressources
Page 112
Quasiment chaque programme Windows utilise des ressources, c'est--dire des lments dinformations relatifs au programme situs hors du code du programme lui-mme. Par exemple, les icnes sont des ressources, tout comme les images, les sons ou les menus. Toutes les ressources dun programme Windows sont spcifies dans un script de ressource spcial, appel fichier RC. Celui-ci est un fichier texte contenant une liste de ressources et qui est compil et li au programme excutable final. La plupart des ressources sont cres et modifies au moyen doutils de ressource visuels. Comme lditeur dicne intgr dans lenvironnement de dveloppement RadAsm. Des types de donnes tranges La plus grande difficult dans lapprentissage de la programmation Windows est peut tre de se sentir laise avec les types de donnes tranges qui sont utilis dans tout programme Windows. Un des types de donnes les plus communes est appel descripteur (handle). Sous Windows, un descripteur est un nombre qui fait rfrence un objet Windows graphique, comme une fentre ou une icne. Les descripteurs sont importants, parce que Windows dplace souvent les objets dans la mmoire et que les adresses mmoire, de ce fait, sont des cibles mouvantes . Les descripteurs sont utiliss dans toute lAPI Win32 pour manipuler les objets Windows. Ainsi formule, cette notion de descripteur vous semble peut-tre abstraite et difficile saisir. Mais vous la comprendrez bien mieux ds lors que vous la verrez mise en pratique dans un programme Windows. Outre les descripteurs, lAPI Win32 introduit toute une gamme de nouveaux types de donnes, qui peuvent sembler trange au novice. Tous les types de donnes Win32 tant crit en majuscules, ils sont faciles identifier. Par exemple, RECT est un type de donnes assez simple et couramment utilis. RECT reprsente une structure rectangulaire. HWND est galement un type de donnes assez courant, qui reprsente la poigne dune fentre. Compte tenu du grand nombre de types de donnes utiliss dans lAPI Win32, nous ne les passerons par tous symtriquement en revue dans ce chapitre. En revanche, nous dcrirons les types de donnes de cette API au fur et mesure que nous les rencontrons dans les programmes de ce guide. Convention spciale de nommage Si vous avez dj jet un coup dil sur un programme Windows, vous vous tes peut-tre interrog sur les noms des variables. Les programmeurs cherchent depuis toujours trouver le moyen dcrire du code qui soit facile comprendre. Windows rend cette tche particulirement complexe, du fait du grand nombre et de la diversit de ses types de donnes. Le programmeur Microsoft Charles Simonyi, aujourdhui lgendaire, proposa une solution plutt astucieuse ce problme : la notation hongroise (M. Simonyi est hongrois). Dans cette notation, les noms de variables commencent par une lettre ou des lettres minuscules qui sont indicatives du type de donnes de la variable. Par exemple, tous les noms,
Page 113
les variables entires commencent par la lettre i. Voici quelques-uns des prfixes de notation hongroise couramment utiliss dans les programmes Windows : i : entier; b : boolen (BOOL); c : caractre; s : chane; sz : chane termin par zro; p : pointeur; h : descripteur (handle); w : entier court non sign (WORD); dw : entier long non sign (DWORD); l : entier long.
BOOL, WORD et DWORD sont des types de donnes Win32 couramment utiliss. La notation hongroise est facile appliquer. Par exemple, un compteur entier pourrait tre nomm iCompt et un descripteur dicne, hIcone. De la mme manire, une chaine termine par un zro stockant le nom dune quipe sportive pourrait tre appele szNomEquipe. Notez bien que cette notation est totalement optionnelle, mais trs pratique. Nous lappliquerons dans tous les programmes de ce guide, et vous pourrez ainsi juger rapidement de sa commodit. La programmation Windows en pratique Nous pourrions poursuivre ainsi notre expos thorique sur lAPI Win32. Toutefois, tant donn que notre objectif est donc arriv le plus rapidement possible la pratique de lAPI Win32 en assembleur, nous allons directement ltude dun programme Windows. Dans la prochaine section nous tudierons les principaux aspects dun programme Windows, en examinant le code correspondant. A ce stade, il nest pas capital que vous compreniez chaque ligne du code. Une simple fentre Ci-dessous voici le code source de notre programme ouvrant une simple fentre. Avant une plonge dans les entrailles de la programmation Win32 assembleur, regardons quelques points importants qui soulageront votre programmation. Vous devez mettre tous les constants Windows, les structures et les prototypes de fonction dans un fichier includeE (*.inc) et l'inclure au dbut de votre fichier .asm. Cela vous vitera de gros efforts de rcriture par vous mme. Actuellement, la plupart des fichiers INCLUDE ,tel que windows.inc, sont
Page 114
complets. Vous pouvez aussi dfinir vos propres constants et structures mais vous devez les mettre dans un fichier INCLUDE (*.inc) diffrent de 'windows.inc'. Les constants Windows, les structures et les prototypes de Fonction sont toutes des instructions assembleur. Donc si vous n'avez pas compris, on crit seulement des bouts de programme en ASM dans des fichiers *.inc et quand vous en avez besoin pour un de vos programmes, vos y faites rfrence grce une instruction spciale :'INCLUDE' Utilisez la directive includelib pour indiquer quelle bibliothque d'importation est employe par votre programme. Par exemple, si votre programme appelle la fonction MessageBox, vous devez mettre la ligne : includelib user32.lib Au dbut de votre fichier .asm. Cette directive informe MASM que votre programme utilisera certaines fonctions dans cette bibliothque d'importation. Si vos fonctions d'appels de programme ne font pas parti de la mme bibliothque, ajoutez juste un IncludeLib pour chaque bibliothque que vous employez. En employant la directive IncludeLib, vous n'avez plus vous inquitez des bibliothques d'importations. En dclarant des prototypes de fonction API, des structures, ou des constants pour les inclure dans vos propres fichiers, essayez de respecter les noms d'origines employs par les fichiers INCLUDE de Windows. a vous vitera bien des maux de tte chercher quelque article dans la rfrence Win32 API.
Page 115
Page 116
Page 117
Un tel listing a de quoi effrayer le profane. Nous le donnons ici dun bloc pour que vous ayez une ide de contenu dun programme Windows complet. Heureusement, la plupart de ces codes sont juste une ossature commune pour tous les programmes. Ces codes que vous pouvez les copier d'un fichier de code source un autre. Ou si vous prfrez, vous pourriez assembler quelques-uns de ces codes dans une bibliothque pour tre employs comme une sorte dintroduction dans votre programme. Le prochain chapitre dissimulera une grande partie de ce code, dont vous naurez plus alors vous soucier. Mais, avant cela, examinons ce programme dans ses grandes lignes. Les trois premires lignes sont ncessaires. .386 dit MASM que nous avons l'intention d'employer le jeu d'instruction de processeur 80386 dans ce programme. .model flat, stdcall dit MASM que notre programme emploie la mmoire plate adressant le modle. C'est pourquoi nous employions le paramtre stdcall prenant par dfaut cette convention dans notre programme. Ensuite c'est au tour du prototype de fonction de WinMain. Puisque nous appellerons WinMain plus tard, nous devons dfinir son prototype de fonction d'abord, pour que nous puissions l'invoquer par la suite. Nous devons inclure windows.inc au dbut du code source. Il contient les structures importantes et les constants qui sont employs par notre programme. Le fichier INCLUDE, windows.inc, est simplement un
Page 118
fichier texte. Vous pouvez l'ouvrir avec n'importe quel diteur de texte. Notez s'il vous plat que windows.inc ne contient pas toutes les structures et constants (encore). Notre programme appelle les fonctions API qui rsident dans user32.dll (CreateWindowEx,
RegisterWindowClassEx, par exemple) et kernel32.dll (ExitProcess), donc nous devons li notre programme avec ces deux bibliothques d'importation. La question suivante : comment puis-je savoir qui importe la bibliothque qui doit tre lie avec mon programme ? La rponse : Vous devez savoir o rsident les fonctions API appeles par votre programme. Par exemple, si vous appelez une fonction API dans gdi32.dll, vous devez vous lier avec gdi32.lib. C'est l'approche spcifique de MASM. Pour TASM, la bibliothque d'importation qui est lie votre programme est uniquement : import32.lib. C'est beaucoup, beaucoup plus simple.
Ci-dessus on trouve les deux sections pour les "DATA". Dans .data, on dclare deux donnes termines chacune par zro : ClassName dsigne la classe de fentre partir de laquelle la fentre va tre cre. AppName dsigne le nom de la fentre, c'est--dire, dans le cas d'une fentre, le string qui va tre affiche en guise de titre. Notez que les deux variables sont initialises. Dans .data?, deux variables sont dclares : HINSTANCE dsigne linstance Handle de notre programme. CommandLine dsigne la ligne de commande de notre programme. Ces deux donnes sont extrmement courantes, HINSTANCE et LPSTR, sont vraiment de nouveaux noms (de type: DWORD). Vous pouvez les voir dans windows.inc. Notez que chacune des variables se trouvant dans la section .data? ne sont pas initialises, c'est--dire qu'elles ne doivent pas contenir de valeur spcifique en dmarrage, mais nous rservons de l'espace pour notre future utilisation.
Page 119
.code contient toutes vos instructions ASM. Vos codes doivent rsider entre le label start et le label "End Start ". Notre premire instruction est l'appel GetModuleHandle pour aller chercher l'Instance handle de notre programme. Sous Win32, l'Instance Handle et Module Handle sont les mmes. Vous pouvez vous reprsenter l'Instance Handle comme le n d'identification de votre programme. Il est employ comme paramtre par plusieurs des fonctions API que notre programme doit appeler, donc c'est gnralement une bonne ide de le dclarer ds le dbut de notre programme. Notez : En ralit sous win32, l'Instance Handle est l'adresse linaire de votre programme dans la mmoire. Aprs avoir fait appel une fonction de Win32 (une API), la valeur de retour de cette fonction, est place dans eax. Toutes les autres valeurs sont renvoyes par des variables que vous avez vous-mme dfini avant le Call qui appel cette fonction. Une fonction Win32 (ou une procdure) que vous appelez (Call) souvent prservera les registres de segment ebx, edi, esi et le registre ebp. Au contraire, ecx et edx sont considrs comme des registres de travail et sont toujours indfinis aprs la sortie d'une fonction de Win32 (sortie d'une procdure). Notez : n'esprez pas que les valeurs d'eax, ecx, edx soient prservs aprs un appel de fonction API. La ligne qui suit un appel (un call) une fonction d'API, attend en retour une valeur dans eax. Ds que vous appelez une fonction API de Windows, vous devez utiliser la rgle suivante : prservez puis rtablissez les valeurs des registres de segment ebx, edi, esi et ebp aprs le retour de la fonction sinon votre programme plantera peu de temps aprs, ceci est valable pour vos procdures Windows et pour les fonctions de rappel de service Windows. L'appel 'GetCommandLine' est inutile si votre programme ne traite pas de ligne de commande. Dans cet exemple, je vous montre comment l'appeler dans le cas o vous en auriez besoin dans votre programme.
Page 120
Vient ensuite l'appel de WinMain. Ici il reoit quatre paramtres : l'Instance Handle de notre programme, l'Instance Handle du prcdent Instance de notre programme (un programme de plus haut niveau qui aurait appel le notre), la Command Line et l'tat de la fentre sa premire apparition. Sous Win32, il n'y a aucun Instance prcdent (premier). Chaque programme est seul dans son espace d'adresse, donc la valeur d'hPrevInst vaut toujours 0. C'est un des restes de Win16 quand tous les programmes taient encore excuts dans un mme espace d'adresses pour savoir si c'tait le premier Instance ou non. Donc sous win16, si hPrevInst est NULL, alors c'est que c'est le premier Instance. le petit dernier ne vous servira probablement pas souvent : il s'agit du mode d'affichage (visible, invisible, minimis etc.) de la fentre principale. Notez : Vous n'tes pas oblig de dclarer le nom de fonction en tant que : 'WinMain'. En fait, vous avez une totale libert cet gard. Et mme, vous pouvez ne pas employer de fonction WinMainquivalent du tout. Le but est de placer votre code (votre vritable programme) l'intrieur de la fonction WinMain ct de GetCommandLine et votre programme sera toujours capable de fonctionner parfaitement. A la sortie de WinMain, eax est rempli du code de sortie. Nous passons ce code de sortie comme paramtre ExitProcess qui sert terminer notre programme.
La susdite ligne est la dclaration de la fonction WinMain. Notez l'ensemble des paramtres qui suivent la directive PROC. Ce sont les paramtres que WinMain reoit de la fonction qui l'appelle. Vous pouvez utiliser les noms de ces paramtres au lieu de vous servir de la pile pour pousser les valeurs de vos paramtres.
Nous aurons besoin pour afficher la fentre de plusieurs variables : wc est la classe de fentre ncessaire la construction de la fentre principale. C'est en fait une liste d'informations permettant par la suite de crer la fentre selon notre bon vouloir. msg, quant lui, est comme son nom l'indique un message systme, utilis pour communiquer entre l'utilisateur et les fentres : il s'agit en fait du descriptif d'un vnement. hwnd est de type HWND, qui veut dire handle de fentre.
Page 121
Les lignes ci-dessus sont vraiment simples par leur concept. Il s'agit juste de plusieurs lignes d'instruction regroupes. Le concept qui se cache derrire toutes ces lignes c'est d'initialiser la Windows class.
La classe de fentre Une 'Windows Class' ou classe de fentre n'est rien de plus que la premire bauche d'une fentre. On dfinit donc plusieurs caractristiques importantes d'une fentre comme son icne, son curseur, la fonction qui la contrle, sa couleur etc. Vous dfinissez la fentre grce sa 'Windows Class'. C'est en quelque sorte le but de ce concept. Si vous voulez crer plusieurs fentres avec les mmes caractristiques, il serait temps de penser stocker toutes ces caractristiques dans un unique endroit (donc dans une procdure par exemple) et de s'y rfrer quand c'est ncessaire. Cet arrangement conomisera pas mal de mmoire en vitant la duplication d'informations. Windows doit tre trs efficace dans l'utilisation des ressources mmoires, qui restent encore rares. Faisant le point : toutes les fentres gnres par un programme Windows sont cres partir dune classe de fentre, qui est un modle dfinissant tous les attributs dune fentre. Plusieurs fentres peuvent tre gnres partir dune mme classe de fentre. Par exemple, il existe une classe de fentre Win32 standard qui dfinit les attributs dun bouton et qui est utilise pour crer tous les boutons dans Windows. Pour crer une fentre de votre cru, vous devez enregistrer une classe de fentre, puis crer une fentre partir de cette classe. Pour pouvoir crer de nouvelles fentres partir dune classe de fentre, la classe de fentre doit tre enregistre auprs de Windows, en utilisant la fonction de lAPI Win32 RegisterClass ou RegisterClassEx. Une fois quune classe de fentre a t enregistre, vous pouvez lutiliser pour crer autant de fentres quil vous sied.
Page 122
Dans lAPI Win32, les classes de fentre sont reprsentes par une structure de donne appele WNDCLASS ou WNDCLASSEX, cette structure va nous permettre de dfinir un type de fentre part entire dont on pourra crer des exemplaires volont. Vous pouvez, par exemple, voir cette structure comme un patron sur papier pour une maison dfinissant compltement les caractristiques de votre maison et permettant de crer autant d'exemplaire de cette maison que vous le dsirez. WNDCLASSEX est dfinie de la manire suivante :
Quelques-uns des types de donnes tranges voqus prcdemment dans ce chapitre apparaissent dans ce code. A ce stade, nous navons pas besoin dexpliquer ce morceau de code ligne par ligne. Nous nous contenterons dexaminer quelques unes de ces lments les plus intressants : cbSize : La taille de la structure WNDCLASSEX en octets. Nous pouvons employer l'oprateur SIZEOF pour obtenir (initialiser) cette valeur. style : correspond une combinaison de plusieurs options de style comme WS_CAPTION et WS_BORDER qui dterminent laspect et le comportement de la fentre. cbWndExtra: Indique le nombre d'octets supplmentaires allouer en fonction de la 'Windows Instance'. Le systme d'exploitation initialise les octets zro.
Page 123
cbClsExtra: Indique le nombre d'octets supplmentaires allouer en fonction de la structure (ses lments) de la Windows Class choisie. Le systme d'exploitation initialise les octets zro. Vous pouvez stocker des donnes spcifiques la Windows Class ici.
lpfnWndProc : est un pointeur sur une fonction du programme qui reoit et traite des messages dvnements dclenchs par lutilisateur. hIcon et hCursor : contiennent les handles vers licne et le curseur de programme. Obtenez-les aprs l'appel de LoadIcon et LoadCursor. lpszMenuName : pointe sur une chaine dfinissant le menu associ cette fentre, ici, il n'y en aura aucun. lpszClassName : pointe sur une chane zro terminal contenant le nom de la classe de la fentre.
Ces lments sont relatifs aux parties dune fentre les plus videntes. lpfnWndProc est probablement le plus subtil comprendre, parce quil sagit dun pointeur sur la procdure de fentre de la classe de fentre. Nous reviendrons un peu plus loin sur cette procdure de fentre. Les lments hIcon et hIconSm sont utiliss pour dfinir les icnes de la classe de fentre : ils correspondent aux icnes de programme qui sont visibles lorsquun programme est en cours dexcution sous Windows. hCursor sutilise pour dfinir un pointeur de souris spcial pour la classe de fentre, qui se substitue au pointeur flche standard. Et pour finir, hbrBackground sutilise pour dfinir larrire-plan de la classe de fentre. Le blanc est utilis comme couleur darrire plan pour la majorit des fentres, mais vous pouvez trs bien choisir une autre couleur. Une fois encore, il nest pas ncessaire ce stade que vous compreniez en dtail la structure dune classe de fentre. Lide est seulement ici de vous familiariser suffisamment avec la programmation Win32 pour que nous puissions assembler un programme complet. Un peu plus loin dans ce chapitre, nous ferons usage de la structure de classe de fentre pour crer un programme Windows minimal.
Cration dune fentre
Aprs l'enregistrement de la classe de fentre, la cration dune fentre principale reprsente la partie critique dun programme Windows. Pour crer une fentre, vous devez en passer par une classe de fentre. Bien que les classes de fentre dfinissent les caractristiques gnrales dune fentre. Ces attributs doivent tre spcifis sous la forme darguments de la fonction CreateWindowEx. Celle-ci est la fonction de lAPI Win32 ddie la cration de la fentre. Lexemple qui suit montre comment crer une
Page 124
fentre au moyen de la fonction CreateWindowEx, Remarquez qu'il y a 12 paramtres cette fonction, beuurr ! ! !
Il nest pas vital que vous compreniez chacune des lignes de ce fragment du code. Nous allons nous contenter den tudier les aspects les plus intressants. Tout dabord, dwExStyle cest le style de fentre supplmentaire. C'est le nouveau paramtre qui est ajout la vieille fonction 'CreateWindow'. Vous pouvez mettre des nouveaux styles de fentre pour Windows 9x & NT ici. En temps normal, vous pouvez spcifier votre style de fentre ordinaire dans dwStyle, mais si vous voulez certains styles spciaux pour une fentre 'tip top', vous devez les spcifier ici. Vous devez employer un NULL si vous ne voulez pas de styles de fentre supplmentaires. Le nom de la classe de fentre est spcifi comme argument, ClassName. Aprs vient le titre de la fentre, Lassembleur Win32 est super ! . Ce titre apparatra dans la barre de titre de la fentre lexcution du programme. WSOVERLAPPEDWINDOW est un style Win32 standard qui identifie une fentre traditionnelle redimensionnable. Les quatre styles CW_USEDDEFAULT indiquent la position XY de la fentre lcran, ainsi que la hauteur et la largeur de la fentre. Vous pouvez rgler ces paramtres sur des valeurs numriques, mais CW_USEDDEFAULT indique Windows de choisir une valeur par dfaut raisonnable. hWndParent, c'est l'Handle de la fentre parente de votre fentre (si celle-ci existe). Ce paramtre indique Windows si
Page 125
cette fentre est un enfant (Window Child) d'une autre fentre et, si elle l'est, qui est la fentre parente. Notez que ce n'est pas la mme relation Parent-Enfant que les 'multiple document interface' ou (MDI). Les 'Window Child' n'ont pas forcment les mmes caractristiques que leur 'Window Parent'. Ces caractristiques sont uniquement spcifiques l'utilisation interne de chaque fentre. Si la fentre parente est dtruite, toutes ses fentres enfant seront dtruites automatiquement. C'est vraiment trs simple. Dans notre exemple, il y a seulement une fentre, donc ce paramtre reste NULL. hMenu: C'est l'Handle du menu de la fentre. Il est NULL si la Class Menu est utilise. Revenez en arrire un des membres de l'instruction WNDCLASSEX, soit 'lpszMenuName'. lpszMenuName indique le menu par *default* pour la 'Window Class'. Chaque fentre de cette Window Class aura le mme menu par dfaut. moins que vous ne spcifiiez un menu *overriding* pour une fentre spcifique via son paramtre hMenu. hMenu est en ralit un paramtre double usage. Si la fentre que vous souhaitez crer utilise un 'Type de Fentre' (Style) prdtermin (c'est--dire un Control), un tel Control ne peut pas possder de menu. hMenu est employ comme ID de ce Control au lieu de cela. Windows peut dcider si hMenu est vraiment un Handle de menu ou un Control ID en regardant le paramtre lpClassName. Si c'est le nom d'une Window Class prdtermine, hMenu est un Control ID. Si ce n'est pas, ce sera alors l' Handle du menu de votre fentre. hInstance: l'Instance Handle pour le module (la partie) du programme crant la fentre. lpParam: Le pointeur facultatif pour des donnes a passer la fentre. Il est employ par la fentre MDI pour passer les donnes CLIENTCREATESTRUCT. Normalement, cette valeur est mise au NULL, signifiant que l'on ne passe aucunes donnes via CreateWindow. La fentre peut prendre la valeur de ce paramtre aprs l'appel la fonction GetWindowLong. Bon d'accord, elles sont lourdes... mais non, vous n'tes pas obligs de les retenir. Mais force de les utiliser (vous verrez ), vous les connatrez par cur. "C'est en forgeant qu'on devient forgeron" ce qu'il parat.
En retour couronn de succs de CreateWindowEx, l'Handle de la fentre est place dans eax. Nous devons garder cette valeur pour une utilisation future. La fentre que nous venons de crer n'est pas automatiquement affiche. Mais la fentre ne s'affichera pas pour autant. Elle est cre, mais c'est tout. Pour l'afficher, il faut appeler la fonction ShowWindow ! Celle-ci prend en premier paramtre le handle de la fentre dont on veut changer le mode d'affichage, et un DWORD dterminant son mode. Vous pouvez soit utiliser le paramtre de WinMain modeDAffichage, soit utiliser la valeur qu'il prend d'habitude : SW_SHOW. Maintenant que la fentre est en mode "affiche", il faut rafrachir l'cran afin de la montrer l'utilisateur : c'est le rle dUpdateWindow, prenant comme seul paramtre le handle de la
Page 126
fentre. Vous l'utiliserez srement beaucoup aprs avoir cr des contrles enfants d'une fentre, afin de rafrachir l'cran juste aprs leur cration. Je souhaite que nous commencions par quelques explications sur la notion du test et des boucles en MASM avant de continuer analyser notre code. Les Tests La directive conditionnelle .IF MASM dfinit une directive de haut niveau, nomm .IF (n'oubliez pas le point en prfixe), qui simplifie la rdaction des instructions IF composes par rapport l'emploi de CMP et sauts conditionnels; voici la syntaxe formelle:
Les crochets montrent que .ELSEIF et .ELSE sont facultatives alors que .IF et .ENDIF sont obligatoires. Chaque condition est une expression boolenne qui utilise les mmes oprateurs que ceux du C++ et de Java. L'expression n'est pas value que pendant l'excution. Voici quelques exemples de conditions acceptables :
Voici maintenant quelques conditions composes. Nous supposons que val1 et val2 sont des variables de type double-mot :
Le tableau suivant prsente tous les oprateurs relationnels et logiques utilisables. Oprateur Description Renvoie Vrai si expr1 est gale expr2 Renvoie Vrai si expr1 nest pas gale expr2
expr1 = expr2 expr1 != expr2
Page 127
expr1 > expr2
Renvoie Vrai si expr1 est plus grande que expr2 Renvoie Vrai si expr1 est plus grande ou gale expr2 Renvoie Vrai si expr1 est plus petite que expr2 Renvoie Vrai si expr1 est plus petite ou gale expr2 Renvoie Vrai si expr1 est fausse Ralise un AND logique entre expr1 et expr2 Ralise un OU logique entre expr1 et expr2 Ralise un AND binaire entre expr1 et expr2 Renvoie Vrai si le drapeau Carry est arm Renvoie Vrai si le drapeau Overflow est arm Renvoie Vrai si le drapeau Parity est arm Renvoie Vrai si le drapeau Sign est arm Renvoie Vrai si le drapeau Zero est arm
expr1 >= expr2 expr1 < expr2 expr1 <= expr2

!expr
expr1 && expr2 expr1 || expr2 expr1 & expr2

CARRY? OVERFLOW? PARTY? SIGN? ZERO?
Gnration automatique du code ASM Avec les directives de haut niveau telle que .IF et .ELSE, cest le compilateur dassembleur qui va crire les instructions assembleur votre place. Partons par exemple d'une directive .IF qui cherche comparer le contenu de EAX la variable val1:
Nous supposons que val1 et resultat sont des entiers non signs sur 32 bits. Lorsque le compilateur lit les lignes prcdentes, il est considre comme des instructions assembleur :
Page 128
Le nom du label @C0001 a t cre par l'assembleur (c'est pourquoi il est peu lisible). Cette convention permet de garantir tous les noms de labels sont uniques dans chaque procdure. Comparaison signes et non signs Lorsque vous utiliser .IF pour comparer des valeurs, vous devez vous mfiez de la manire dont sont gnrs les sauts conditionnels. Si c'est la comparaison concerne une variable non signe, c'est une instruction de saut conditionnel non signe qui sera insre dans le code gnr. Voici un exemple trs proche du prcdant avec comparaison entre eax et val1 qui est un double mot non sign :
L'assembleur comprend ces lignes en choisissant d'utiliser linstruction JBE (saut pour non sign) :
Comparaisons d'entiers signs Essayons une comparaison de mme style avec val2, un double-mot sign :
A partir de ces lignes l'assembleur va gnrer du code utilisant l'instruction JLE qui permet un branchement en comparant des valeurs signes :
Page 129
Comparaisons de registres Que se passe-t-il si on veut comparer deux registres ? Il est vident que l'assembleur ne pas en dduire ltat sign ou non sign des valeurs :
Dans ce cas le programme assembleur opte pour la comparaison non sign. Autrement dit la directive .IF utilise pour comparer deux registres donne lieu linjection dune instruction JBE. Expressions composes Nous avons dj rencontr les expressions composes au dbut de chapitre. La plupart des expressions boolennes composes sarticulent autour des deux oprateurs OR et AND. Si vous utilisez la directive .IF, le symbole || reprsente loprateur OR :
Pour l'oprateur AND, son homonyme est && :
Les boucles Et a y est, on y est, on est arrivs, la voil, cest Broadway une autre structure : a est les boucles. Si vous voulez pater vos amis, vous pouvez galement parler de structures rptitives, voire carrment de structures itratives. Ca calme, hein ? Bon, vous faites ce que vous voulez, ici on est entre nous, on parlera de boucles. Bon, alors nous avons vu jusqu'ici les notions de base, les variables, les oprateurs, ainsi que les structures conditionnelles. Mais il manque encore quelques points importants afin de faire un programme digne de ce nom. En effet, les programmes ont parfois besoin de rpter une ou plusieurs instructions pour effectuer une certaine tche. C'est mme encore plus frquent que vous ne pourriez l'imaginer.
Page 130
Les boucles servent rpter une fonction un certain nombre de dois ou jusqu' ce qu'une condition soit vraie. En programmation, on veut souvent pouvoir faire quelque chose un certain nombre de fois. Ce genre de boucle apparat dans toutes les applications possibles et imaginables : les graphismes, les calculs mathmatiques, la cryptologie, l'accs aux fichiers la liste est trop longue. Directives .REPEAT et .WHILE Les directives .REPEAT et .WHILE offrent une solution alternative pour mettre en place des boucles avec CMP et des instructions de saut conditionnel. Elles acceptent les expressions de saut conditionnelles vues au tableau des oprateurs relationnels et logique dexcution. La directive .REPEAT excute les instructions du corps de la boucle avant de tester la condition de boucle qui est place derrire la directive .UNTIL
Le test de condition tant ralis la fin, les instructions qui font partie de la boucle .REPEAT sont toujours excutes au mois une fois. Au contrario, dans la boucle WHILE, si le teste est faux ds le dbut, les instructions ne seront jamais excutes. La directive .WHILE est un peu linverse de la prcdente : elle teste la condition avant dexcuter le premier tour de boucle :
Exemples Lextrait suivant fait la somme des 100 premiers nombres entiers au moyen de la directive .WHILE :
Lextrait suivant fait la somme des 100 premiers nombres entiers au moyen de la directive .REPEAT :
Page 131
Autre exemple : une boucle contenant linstruction .IF Lextrait suivant fait la somme des 100 premiers nombre entiers au moyen de la directive .WHILE en sauvegardant la somme des 50 premiers dans une variables res.
Sortir de la boucle Il peut tre prfrable, dans certains cas, de sortir de la boucle avant que la condition d'arrt n'ait eu lieu. Si vous voulez sortir d'une boucle dans laquelle vous tes directement (c'est--dire que vous n'tes pas dans une sous-boucle, boucle imbriqu), vous avez votre disposition la directive .BREAK. Cette directive sort directement de la boucle dans laquelle vous tes, autrement dites, elle permet de briser la structure de contrle qui l'encadre. Sachez cependant que la directive .BREAK ne sort que de la boucle dans laquelle vous vous trouvez directement. Il vous faudra avoir recours d'autres astuces pour sortir de toutes les boucles embotes d'un coup. Mais je pense que le jour o vous aurez besoin de faire cela, vous trouverez vous-mme la solution. Je ne vais donc pas en rajouter pour le moment; voici la syntaxe formelle:
Il existe galement une autre directive pour contrler une boucle : .CONTINUE. Comme la directive .BREAK, .CONTINUE ne peut tre plac que dans le corps dune boucle. Cette instruction saute directement aprs la dernire instruction de la boucle, mais sans en sortir. On passe donc directement l'itration suivante ; voici la syntaxe formelle:
La directive Goto
Page 132
Cette directive excute un saut inconditionnel ou un branchement. Rencontre au cours de lexcution d un programme, la directive goto provoque la transfert ou le branchement immdiat vers lemplacement dsign. Ce branchement est dit inconditionnel, car il ne dpend daucune condition. La directive goto est son tiquette peuvent se trouver dans des blocs de code diffrents, mais doivent toujours faire partie de la mme fonction. Syntaxe :
Oups ! Dsol ! Je parle, je parle et j'oublie l'essentiel, revenons nos moutons. Cette fois-ci, notre fentre est sur l'cran. Mais elle ne peut pas recevoir d'informations extrieures (comme une saisie de texte ou bien la dtection de la pression d'un bouton). Donc nous devons l'informer de ce qui se passe. Nous faisons a avec une boucle de message.
Traitement des messages Prcdemment dans ce chapitre, nous avons vu que Windows communique avec les programmes en leur transmettant des messages. Nous allons maintenant tudier de plus en dtail le fonctionnement de ces messages Windows. Trois lments information sont associs un message : une fentre ; un identificateur de message ; des paramtres de message.
La fentre associe un message est la fentre laquelle est adress le message. Lidentificateur de
message est un nombre qui identifie la nature du message envoy. Dans lAPI Win32, une constante
numrique est associe chaque message. Par exemple, WM_CREATE, WM_PAINT et
Page 133
WM_MOUSEMOVE sont trois constantes numriques dfinies dans lAPI Win32, qui identifient respectivement les messages associs la cration de la fentre, au trac de fentre et au mouvement de la souris. Les paramtres de message consistent en deux lments dinformation, qui sont entirement spcifiques au message envoy. Ces paramtres 32 bits sont appels wParam et lParam. La signification de ces paramtres dpend du message en cours de traitement. Par exemple, le paramtre wParam du message WM_SIZE contient des informations relatives au type de dimensionnement possible sur la fentre, tandis que le paramtre lParam contient les nouvelles valeurs de la largeur et de la hauteur de la zone interne de la fentre (galement appele zone client de la fentre). La largeur et la hauteur sont stockes dans les mors bas et haut de la valeur lParam 32 bits. Ce mode de stockage est lapproche classiquement utilise dans Win32 pour stocker deux lments dinformation en un mme emplacement. Si la notion du mot haut et bas ne vous est pas familire, ne vous inquitez pas : nous verrons un peu plus loin, quand nous en aurons besoin, comment extraire du paramtre les informations lParam utiles. Lorsquun message est transmis par Windows un programme, il est trait dans ma fonction WndProc (). Si WndProc () est charg de traiter les messages pour une classe de fentre donne, cest au programme quil appartient dacheminer les messages vers les procdures de fentre appropries. Pour cela, on utilise une boucle de message au cur de la fonction WinMain ():
Il y a seulement une boucle de message pour chaque module. Cette boucle de message vrifie continuellement les messages de Windows grce un 'Call GetMessage'. GetMessage passe une donne une structure de MESSAGE de Windows. Cette structure de messagesera remplie de l'information du message que Windows veut envoyer une fentre dans le module. La fonction GetMessage ne retournera pas (ne reviendra pas votre programme mais au contraire restera dans Kernel ou User) tant qu'un message (ex : appui sur un bouton) ne sera pas transmis pour une fentre dans le module. Pendant ce temps-l, Windows peut donner le contrle d'autres programmes. C'est en quelque sorte le fonctionnement en Multigestion de la plate-forme Win16. GetMessage renverra une erreur si le Message WM_QUIT est reu dans la boucle de message, et ainsi nous termineront la boucle et irons vers la sortie du programme. TranslateMessage est une fonction utile qui saisie les entres de clavier ( la vole) et produit un nouveau Message WM_CHAR qui est plac sur la file d'attente des messages. Le message avec
Page 134
WM_CHAR contient la valeur ASCII pour la touche presse, c'est bien plus facile de procder ainsi. Vous pouvez omettre cet appel si votre programme ne traite pas de frappes. 'DispatchMessage' redirige les donnes d'un message (ex : envoi : on vient d'appuyer sur le bouton) la procdure responsable de la fentre spcifique.
Si la boucle de message se termine, le code de sortie est stock dans le membre wParam de la structure de MESSAGE. Vous pouvez stocker ce code de sortie dans eax pour le rendre Windows. Actuellement, Windows ne se sert pas de la valeur de retour, mais c'est mieux de respecter les rgles.
La procdure de fentre
C'est notre procdure Win. Vous ne devez pas la nommer WndProc. Le premier paramtre, hWnd, est l'Handle de la fentre pour laquelle le message est destin. uMsg est le message. Notez qu'uMsg n'est pas une structure de message. C'est juste un numro (nombre). Windows dfinit des centaines de messages, dont la plupart ne seront pas intressants pour vos programmes. Windows enverra un message appropri une fentre seulement si quelque chose d'intressant arrive cette fentre. La procdure qui traite vos fentres reoit le message et y ragit intelligemment. wParam et lParam sont juste des paramtres supplmentaires pour l'utilisation de certains messages. Certains messages envoient des donnes d'accompagnement en plus du message lui-mme. On passe ces donnes la procdure de fentre au moyen de wParam et lParam.
Vient ici la partie cruciale. C'est l'endroit o la plupart de l'intelligence de votre programme rside. Les codes qui rpondent chaque message de Windows sont dans la procdure de fentre (la procdure
Page 135
qui s'occupe du contrle de votre fentre). Votre code doit vrifier le message de Windows pour voir si c'est un message intressant. S'il l'est, faites tout ce que vous voulez faire en rponse ce message et retourner ensuite la valeur zro dans eax. S'il ne l'est pas, vous devez appeler l'API 'DefWindowProc', pour lui passer tous les paramtres que vous y avez reu pour les traiter par dfaut. 'DefWindowProc' est une fonction API qui traite les messages qui ne sont pas intressant pour votre programme. Le seul message que vous pouvez et devez envoyer vers votre procdure qui traite les messages est WM_DESTROY. Ce message est envoy votre procdure de fentre pour la referme. Au moment o votre procdure de fentre reoit ce message, votre fentre est dj enleve de l'cran. C'est juste un renseignement comme quoi votre fentre a bien t dtruite, vous devez vous prparer retourner Windows. Si vous utilisez cela, vous n'avez d'autres choix que de quitter. Si vous voulez avoir une chance d'arrter la fermeture de votre fentre, vous devez utiliser le message WM_CLOSE. Maintenant revenons WM_DESTROY, aprs cette fermeture radicale, vous devez appeler PostQuitMessage qui postera WM_QUIT en retour votre module (traitement du message). WM_QUIT fera le retour de GetMessage avec la valeur zro dans eax, qui son tour, terminera la boucle de message et quittera Windows. Vous pouvez envoyer le message WM_DESTROY votre propre procdure de fentre en appelant la fonction DestroyWindow. Et voil : vous tes prts pour crer votre premire fentre ! En combinant le tout, vous obtenez cette uvre magnifique :
Enfin, presque. Vous aurez srement une barre de titre diffrente, cause du thme de Windows. Voil, ce dernier chapitre est termin, j'espre qu'il vous a plu. Ne vous dcouragez surtout pas face la longueur du code, car cela en vaut la peine, et cela va rentrer progressivement en tant qu'automatisme ;)
Page 136
Conclusion et Remerciements C'est ici ou s'achve notre petite introduction l'assembleur, merci de l'avoir lue! Il vous reste tout dcouvrir, l'API Win32 en ASM est loin d'tre ce que vous avez lu, mais un peu de volont et de motivation vous serez capable dtre un programmeur ASM confirm ;) seule la pratique permettant de faire des progrs et c'est comme ceci que les choses rentrent le mieux, vos claviers ! Je tiens vous dire que "crire" est quelque chose de trs dur, pour cela je remercie inconcevablement tous ceux qui rdigent des tutoriaux et qui les mettent notre disposition, tous ceux qui combattent pour vulgariser l'information et tous ceux qui partagent leurs connaissances par la seule et unique motivation : Le plaisir. Javoue que je me suis inspir de certains livres/ezines/ebooks principalement ceux des trois auteurs Kip Ivrine Assembleur x86 , Jean-Bernard Emond Le tout en poche Assembleur x86 , Michal Morrison, Programmation des jeux . Ce guide est galement inspire de quelques billets savoir notre chre ami la Wiki, du site : http://win32assembly.online.fr/, merci Iczelion, son crateur. Je tiens remercier aussi toute personne ayant contribu la ralisation de ce guide que ce soit de manire directe ou indirecte. Jentends par l : Benot-M, Rmi Coquet, Obsidian, Alcatz, MrGh0st, N@bilX, DaBDouB-MoSiKaR, Mz Sarah, Oussama Fatihi, Yassine Tahiri, Alaa Dounassre, Othmane Basbas, Metal-, lquipe FAT (Kaze, Baboon, Tuna, Ed, Silmaril, Poco, Codasyl), CiM (Esp!onLeRaVaGe!, r007, Willingness, DrNitro, Mr L, X-Crk,, BlackPirate, FiRe, xsp!der, Le_Maudit, ), ForumCrack (BeatriX2004, Squallsurf, Virtualabs, rAsM, ), AT4RE (Mouradpr, GamingMaster, Zeak47, ), Logram-Project (Youscef, Azerty, SteckDennis ) et la liste est longue donc tous ceux que jai oubli. Vos remarques, suggestions, conseils et critiques me seraient trs utiles pour lamliorer encore ; vous pouvez les envoyer Noteworthy@live.fr.
Sweet dreams are made of this Lord Noteworthy, le 22 Avril 2009 // FAT Assembler Team
Page 137
Liens utiles http://www.masm32.com/masmdl.htm MASM32 Version 10 Downloads http://www.oby.ro/rad_asm/ RadASM Assembler IDE HelpPC Reference Library. Win32 Programmer's Reference. Ralf Brown's Interrupt List Assembly Programming Journal Lots of good information about x86 processors X86 Opcode and Instruction Reference MSDN Online Library Intel Assembler Code Table 80x86 - Overview of instructions Intel Hex Opcodes And Mnemonics Intel Architecture Software Developer's Manual, Volume 1 Basic Architecture. Intel Architecture Software Developer's Manual, Volume 2: Instruction Set Reference Manual. Intel Architecture Software Developer's Manual, Volume 3 System Programming Guide. Intel 64-bit Pentium Documentation. - http://webster.cs.ucr.edu/Page_TechDocs/Intel64.pdf Volume 1 - http://webster.cs.ucr.edu/Page_TechDocs/Intel64_2.pdf Volume 2
Rfrences bibliographiques The Art of Assembly Language. Assembly Language: Step-by-Step. Assembly Language Step-by-Step: Programming with DOS and Linux, 2d edition. Write Great Code Understanding the Machine, Volume I. Write Great Code Thinking Low-Level, Writing High-Level, Volume II. 80x86 Assembly Language and Computer Architecture. Professional Assembly Language. Guide to Assembly Language Programming in Linux. The Zen of Assembly Language. Linux Assembly Language Programming. Windows (32-bit) Assembly Tutorials
Page 138
The Microsoft Macro Assembler Programmers Guide. Learn Microsoft Assembler In A Day. The Assembly Programming Master Book. 32/64-Bit 80x86 Assembly Language Architecture. Win32 Assembler Coding for Crackers. The Art of Assembly Language 32-Bit Edition. Masm: Microsoft Assembler http://www.masm32.com/ Nasm: The Netwise Assembler http://www.nasm.us/ Fasm: Flat Assembler http://flatassembler.net/index.php Documentation, FAQ, Exemples... Tasm : Turbo Assembler http://info.borland.com/borlandcpp/cppcomp/tasmfact.html RosAsm: The Bottom-Up Assembler http://betov.free.fr/RosAsm.htm Yasm Modular Assembler: http://www.tortall.net/projects/yasm/ DOS (16-bit) Assembly tutorials Mastering Turbo Assembler, 2d edition. Adams asm tutorials. http://www.programmersheaven.com/d/click.aspx?ID=F15526
[French] Assembleur Pratique de Bernard Fabrot chez Marabout. Assembleur x86 par Jean Bernard Emond - Le Tout en Poche. Introduction la programmation en Assembleur Processeurs 64 bits de la famille 80x86. Une introduction en Assembleur. Apprendre l'assembleur Intel DOS 16bit avec Tasm. Initiation lassembleur. Assembleur i8086. Mthodologie de Programmation en Assembleur. http://www.haypocalc.com/wiki/Assembleur_Intel_x86 Nasm Langage Assembleur PC http://frenchezines.free.fr/tries/counters...ssembleur1.html http://frenchezines.free.fr/tries/counters...ssembleur2.html http://edouard.fazenda.free.fr/pub/ftp/Ezines/asmtutorial/ http://edouard.fazenda.free.fr/pub/ftp/Ezi...asmbeginner.txt
Page 139
Forum incontournable http://fat.next-touch.com/forum/: le forum du site, o rgne une excellente ambiance, qui vous aidera lorsque vous rencontrez des problmes, vous pourrez galement y demander des conseils http://www.developpez.net/forums/ : la plus importante communaut francophone ddie au dveloppement informatique. http://www.forumcrack.com/forum/ http://www.winasm.net/forum/ http://www.masm32.com/board/ http://www.asmcommunity.net/
Code Source http://win32assembly.online.fr/source.html Masm32 http://www.magma.ca/~wjr/ http://asmsource.cjb.net/ http://www.asmfr.com/ http://www.geocities.com/SiliconValley/Heights/7394/ http://rs1.szif.hu/~tomcat/win32/ Win32Nasm http://pagesperso-orange.fr/vombonjour/myprogs.html http://www.team-x.ru/guru-exe/index.php?path=Sources/
Autres cours http://www.csc.depauw.edu/~bhoward/asmtut/ Nasm 16bit http://thsun1.jinr.ru/~alvladim/man/asm.html#5 http://www.drpaulcarter.com/pcasm/pcasm-book-french-pdf.zip Nasm 32bit [FR] http://www.xs4all.nl/~smit/asm01001.htm#index1 Tasm 16bit http://web.cecs.pdx.edu/~bjorn/CS200/linux_tutorial/ Nasm http://www.btinternet.com/~btketman/tutpage.html Tasm 16bit http://www.doorknobsoft.com/tutorial/asm-t...rning-assembly/ Tasm 16bit.
Page 140
http://www.chez.com/asmgges/index.htm 32bit Fasm, Nasm, GoAsm, RosAsm tuts, http://www.asm32.motion-bg.com/ http://www.jorgon.freeserve.co.uk/ http://www.int80h.org/bsdasm/ Nasm 32bit http://burks.bton.ac.uk/burks/language/asm/asmtut/asm1.htm http://www.deinmeister.de/wasmtute.htm http://www.hochfeiler.it/alvise/index.html http://www.geocities.com/emu8086/index.html http://www.gentle.it/alvise/w32p.htm http://www.geocities.com/technosoftt/ http://pagesperso-orange.fr/vombonjour/ http://members.a1.net/ranmasaotome/main.html http://games-creators.org/wiki/PureBasic#T...x_ASM_.28x86.29 http://www.avr-asm-tutorial.net/avr_en/ http://webster.cs.ucr.edu/Page_TechDocs/asmstyle.html http://assembly.ifrance.com/assembly http://www.osdata.com/topic/language/asm/asmintro.htm
Page 141

Pas A Pas L'assembleur

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Pas A Pas L'assembleur

Încărcat de

Drepturi de autor:

Formate disponibile

Table des matires

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Chapitre 5 : Lenvironnement Windows......65

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

La directive Goto..107 Traitement des messages..108 La procdure de fentre.....................109

Conclusion et remerciement..137 Annexes......138

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Haut niveau Langage humain : (Par exemple, langlais)

If the line is not busy, connect to the internet; Else, wait

Langage de programmation : Haut niveau (Par exemple, le C)

If (line ! = busy) connect (Internet); Else wait (5)

Langage Machine : (code binaire)

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Ou bien encore : 4687 = 4 1000 + 6 100 + 8 10 + 7

By: Lord Noteworthy / FAT Assembler Team

Notez l'utilisation d'un B majuscule pour diffrencier Byte et bit.

By: Lord Noteworthy / FAT Assembler Team

1 octet de poids faible (Most Significant Byte).

Si on fait un schma de ce quon vient de dire, on se retrouve avec ce qui suit :

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

7 8 9 10 11 12 13 14 15 16 17 Les conversions entre bases numrales

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Attention au sens de lecture

By: Lord Noteworthy / FAT Assembler Team

Lcriture binaire de 77d est donc : 01001101b.

By: Lord Noteworthy / FAT Assembler Team

On y est le nombre scrit donc en hexadcimal : BDh

By: Lord Noteworthy / FAT Assembler Team

Donc 1d sera reprsent par FFh. Recommenons et soustrayons 1 -1 : 1 1 1 1 1 1 1 1 1

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Pour illustrer ce principe, effectuons par exemple les oprations suivantes :

By: Lord Noteworthy / FAT Assembler Team

------------------------18 4 ------------------------= = 8 8 22 2 -------------------------

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

By: Lord Noteworthy / FAT Assembler Team

Finesse de gravure (m)

Largeur des donnes

4 bits/4 bits bus

8 bits/8 bits bus

16 bits/8 bits bus

16 /16 bits bus

By: Lord Noteworthy / FAT Assembler Team

32 bits/32 bits bus

32 bits/32 bits bus

32 bits/64 bits bus

233 450 MHz

32 bits/64 bits bus

450 1400 MHz

32 bits/64 bits bus