/usr/share/doc/HOWTO/fr-html/Assembly-HOWTO.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Linux/x86 (vers 25 March 2009), see www.w3.org">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.69">
<title>Assembly HOWTO</title>
</head>
<body>
<h1>Assembly HOWTO</h1>
<h2>Fran&ccedil;ois-Ren&eacute; Rideau
<code>rideau@ens.fr</code></h2>
v0.4l, 16 Novembre 1997
<hr>
<em>(Version fran&ccedil;aise r&eacute;alis&eacute;e par Eric Dumas
<code>dumas@freenix.fr</code> <code>dumas@Linux.EU.Org</code>, et
Far&eacute; Rideau <code>rideau@ens.fr</code>, 11 Novembre 1997).
Ce document d&eacute;crit comment programmer en assembleur x86 en
n'utilisant que des outils de d&eacute;veloppement <em>libres</em>,
et tout particuli&egrave;rement avec le syst&egrave;me
d'exploitation Linux sur la plate-forme i386. Les informations
contenues dans ce document peuvent &ecirc;tre applicables ou non
applicables &agrave; d'autres plates-formes mat&eacute;rielles ou
logicielles. Les contributions &agrave; ce documents seront
accept&eacute;es avec gratitude. <em>mots-clefs</em>: assembleur,
libre, macroprocesseur, pr&eacute;processeur, asm, inline asm, 32
bits, x86, i386, gas, as86, nasm</em>
<hr>
<h2><a name="s1">1. Introduction</a></h2>
<h2><a name="ss1.1">1.1 Copyright</a></h2>
<p>Copyright &copy; 1996,1997 Fran&ccedil;ois-Ren&eacute; Rideau.
Ce document peut &ecirc;tre redistribu&eacute; sous les termes de
la license LDP, disponibles &agrave; <a href=
"http://sunsite.unc.edu/LDP/COPYRIGHT.html">http://sunsite.unc.edu/LDP/COPYRIGHT.html</a>.</p>
<h2><a name="ss1.2">1.2 Note importante</a></h2>
<p>Ceci est cens&eacute; &ecirc;tre la derni&egrave;re version que
j'&eacute;crirai de ce document. Il y a un candidat pour reprendre
en charge le document, mais jusqu'&agrave; ce qu'il le reprenne
compl&egrave;tement en main, je serai heureux de m'occuper de tout
courrier concernant ce document.</p>
<p>Vous &ecirc;tes tout sp&eacute;cialement invit&eacute;s &agrave;
poser des questions, &agrave; y r&eacute;pondre, &agrave; corriger
les donn&eacute;es, &agrave; ajouter de nouvelles informations,
&agrave; compl&eacute;ter les r&eacute;f&eacute;rences sur d'autres
logiciels, &agrave; mettre en &eacute;vidence les erreurs et
lacunes du document. Si vous &ecirc;tes motiv&eacute;s, vous pouvez
m&ecirc;me <b>prendre en charge ce document</b>. En un mot,
apporter votre contribution!</p>
<p>Pour contribuer &agrave; ce document, contactez la personne qui
appara&icirc;t actuellement en charge. Au moment o&ugrave;
j'&eacute;cris ces lignes, il s'agit de <a href=
"mailto:rideau@clipper.ens.fr">Fran&ccedil;ois-Ren&eacute;
Rideau</a>) ainsi que de <a href=
"mailto:paul@geeky1.ebtech.net">Paul Anderson</a>.</p>
<h2><a name="ss1.3">1.3 Avant-Propos</a></h2>
<p>Ce document est destin&eacute; &agrave; r&eacute;pondre aux
questions les plus fr&eacute;quemment pos&eacute;es par les gens
qui d&eacute;veloppent ou qui souhaitent d&eacute;velopper des
programmes en assembleurs x86 32 bits en utilisant des logiciels
<em>libres</em>, et tout particuli&egrave;rement sous Linux. Vous y
trouverez &eacute;galement des liens sur d'autres documents
traitant d'assembleur, fond&eacute;s sur des outils logiciels qui
ne sont pas libres, pas 32-bit, ou pas d&eacute;di&eacute;s
&agrave; l'architecture x86, bien que cela ne soit pas le but
principal de ce document.</p>
<p>Etant donn&eacute; que l'int&eacute;ret principal de la
programmation en assembleur est d'&eacute;tablir les fondations de
syst&egrave;mes d'exploitation, d'interpr&eacute;teurs, de
compilateurs, et de jeux, l&agrave; o&ugrave; un compilateur C
n'arrive plus &agrave; fournir le pouvoir d'expression
n&eacute;cessaire (les performances &eacute;tant de plus en plus
rarement un probl&egrave;me), nous insisteront sur le
d&eacute;veloppement de tels logiciels.</p>
<h3>Comment utiliser ce document</h3>
<p>Ce document contient des r&eacute;ponses &agrave; un certain
nombre de questions fr&eacute;quemment pos&eacute;es. Des URL y
sont donn&eacute;s, qui pointent sur des sites contenant documents
ou logiciels. Prenez conscience que les plus utiles de ces sites
sont dupliqu&eacute;s sur des serveurs miroirs, et qu'en utilisant
le site miroir le plus proche de chez vous, vous &eacute;vitez
&agrave; un g&acirc;chis inutile aussi bien de pr&eacute;cieuses
ressources r&eacute;seau communes &agrave; l'Internet que de votre
propre temps. Ainsi, il existe un certain nombre de gros serveurs
diss&eacute;min&eacute;s sur la plan&egrave;te, qui effectuent la
duplication d'autres sites importants. Cherchez o&ugrave; se
trouvent ces sites et identifiez les plus proches de chez vous (du
point de vue du r&eacute;seau). Parfois, la liste des miroirs est
donn&eacute;es dans un fichier ou dans le message de connexion.
Suivez ces conseils. Si ces informations ne sont pas
pr&eacute;sentes, utilisez le programme archie.</p>
<p>La version la plus r&eacute;cente de ce document peut &ecirc;tre
trouv&eacute;e sur</p>
<p><a href=
"http://www.eleves.ens.fr:8080/home/rideau/Assembly-HOWTO">http://www.eleves.ens.fr:8080/home/rideau/Assembly-HOWTO</a>
ou <a href=
"http://www.eleves.ens.fr:8080/home/rideau/Assembly-HOWTO.sgml">http://www.eleves.ens.fr:8080/home/rideau/Assembly-HOWTO.sgml</a></p>
<p>mais les r&eacute;pertoires de HowTo Linux <em>devraient</em>
normalement &ecirc;tre &agrave; peu pr&egrave;s &agrave; jour (je
ne peux pas le garentir):</p>
<p><a href=
"ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/">ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/</a>
(?)</p>
<p>La version fran&ccedil;aise de ce document peut &ecirc;tre
trouv&eacute;e sur le site</p>
<p><a href=
"ftp://ftp.ibp.fr/pub/linux/french/HOWTO/">ftp://ftp.ibp.fr/pub/linux/french/HOWTO/</a></p>
<h3>Autres documents de r&eacute;f&eacute;rence</h3>
<ul>
<li>si vous ne savez ce qu'est le <em>libre</em> logiciel, lisez
avec attention la GPL (GNU General Public License), qui est
utilis&eacute;e dans un grand nombre de logiciels libres, et est
une source d'inspiration pour la plupart des autres licences
d'utilisations de logiciels libres. Elle se trouve
g&eacute;n&eacute;ralement dans un fichier nomm&eacute;
<code>COPYING</code>, avec une version pour les
biblioth&egrave;ques de routines dans un fichier nomm&eacute;
<code>COPYING.LIB</code>. Les &eacute;crits publi&eacute;s par la
FSF (free software foundation) peuvent &eacute;galement vous aider
&agrave; comprendre le ph&eacute;nom&egrave;ne.</li>
<li>plus pr&eacute;cis&eacute;ment, les logiciels libres
int&eacute;ressants sont ceux desquels les sources sont
disponibles, que l'on peut consulter, corriger, et desquels on peut
emprunter une partie. Lisez les licences d'utilisation avec
attention et conformez-vous y.</li>
<li>il existe une FAQ dans le forum de discussion comp.lang.asm.x86
qui r&eacute;pond aux questions g&eacute;n&eacute;rales concernant
la programmation en assembleur pour x86, et aux questions
concernant certains assembleurs commerciaux dans un environnement
DOS 16 bits. Certaines de ces r&eacute;ponses peuvent s'appliquer
&agrave; la programmation 32 bits, aussi serez-vous sans-doute
int&eacute;ress&eacute;s de lire cette FAQ... <a href=
"http://www2.dgsys.com/~raymoon/faq/asmfaq.zip">http://www2.dgsys.com/~raymoon/faq/asmfaq.zip</a></li>
<li>Sont disponibles des FAQs, de la documentation, et des sources,
concernant la programmation sur votre plate-forme
pr&eacute;f&eacute;r&eacute;e, quelqu'elle soit, et vous devriez
les consulter pour les probl&egrave;mes li&eacute;s &agrave; votre
plate-forme qui ne seraient pas sp&eacute;cifique &agrave; la
programmation en assembleur.</li>
</ul>
<h2><a name="ss1.4">1.4 Historique de document</a></h2>
<p>Chaque version inclue quelques modifications et corrections
mineures, qui ne sont pas indiqu&eacute;es &agrave; chaque
fois.</p>
<dl>
<dt><b>Version 0.1 23 Avril 1996</b></dt>
<dd>
<p>Francois-Rene "Far&eacute;" Rideau &lt;rideau@ens.fr&gt;
cr&eacute;e et diffuse initialement le document sous forme d'un
mini-HOWTO car ``Je suis un peu fatigu&eacute; d'avoir &agrave;
r&eacute;pondre encore et toujours aux m&ecirc;mes questions dans
le forum comp.lang.asm.x86''</p>
</dd>
<dt><b>Version 0.2 4 Mai 1996</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.3c 15 Juin 1996</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.3f 17 Octobre 1996</b></dt>
<dd>
<p>Tim Potter indique l'option -fasm pour activer l'assembleur
en-ligne de GCC sans le reste des optimisations de -O.</p>
</dd>
<dt><b>Version 0.3g 2 Novembre 1996</b></dt>
<dd>
<p>Cr&eacute;ation de l'historique. Ajout de pointeurs dans la
section sur la compilation crois&eacute;e. Ajout d'une section
concernant la programmation des entr&eacute;es/sorties sous Linux
(en particulier pour l'acc&egrave;s vid&eacute;o).</p>
</dd>
<dt><b>Version 0.3h 6 Novembre 1996</b></dt>
<dd>
<p>plus sur la compilation crois&eacute;e - voir sur sunsite:
devel/msdos/</p>
</dd>
<dt><b>Version 0.3i 16 Novembre 1996</b></dt>
<dd>
<p>NASM commence &agrave; &ecirc;tre particuli&egrave;rement
int&eacute;ressant</p>
</dd>
<dt><b>Version 0.3j 24 Novembre 1996</b></dt>
<dd>
<p>R&eacute;f&eacute;rence sur la version fran&ccedil;aise</p>
</dd>
<dt><b>Version 0.3k 19 D&eacute;cembre 1996</b></dt>
<dd>
<p>Quoi? J'avais oubli&eacute; de parler de Terse?</p>
</dd>
<dt><b>Version 0.3l 11 Janvier 1997</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.4pre1 13 Janvier 1997</b></dt>
<dd>
<p>Le mini-HOWTO au format texte est transform&eacute; en un
authentique HOWTO au format linuxdoc-sgml, pour explorer les
possibilit&eacute;s dudit format.</p>
</dd>
<dt><b>Version 0.4 20 Janvier 1997</b></dt>
<dd>
<p>Premi&egrave;re diffusion de ce HOWTO.</p>
</dd>
<dt><b>Version 0.4a 20 Janvier 1997</b></dt>
<dd>
<p>Ajout de la section CREDITS</p>
</dd>
<dt><b>Version 0.4b 3 F&eacute;vrier 1997</b></dt>
<dd>
<p>NASM mis avant AS86</p>
</dd>
<dt><b>Version 0.4c 9 F&eacute;vrier 1997</b></dt>
<dd>
<p>Ajout de la partie "Avez-vous besoin d'utilisateur
l'assembleur?"</p>
</dd>
<dt><b>Version 0.4d 28 F&eacute;vrier 1997</b></dt>
<dd>
<p>Annonce fant&ocirc;me d'un nouveau responsable de ce HowTo.</p>
</dd>
<dt><b>Version 0.4e 13 Mar 1997</b></dt>
<dd>
<p>Version diffus&eacute;e pour DrLinux</p>
</dd>
<dt><b>Version 0.4f 20 Mars 1997</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.4g 30 Mars 1997</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.4h 19 Juin 1997</b></dt>
<dd>
<p>Ajouts &agrave; propos de "Comment ne pas utiliser
l'assembleur"; mises &agrave; jour concernant NASM et GAS.</p>
</dd>
<dt><b>Version 0.4i 17 Juillet 1997</b></dt>
<dd>
<p>Informations sur l'acc&egrave;s au mode 16 bits &agrave; partir
de Linux.</p>
</dd>
<dt><b>Version 0.4j 7 September 1997</b></dt>
<dd>
<p>*</p>
</dd>
<dt><b>Version 0.4k 19 Octobre 1997</b></dt>
<dd>
<p>je (Far&eacute;) reprends en main la traduction fran&ccedil;aise
du HowTo</p>
</dd>
<dt><b>Version 0.4l 16 Novembre 1997</b></dt>
<dd>
<p>version pour LSL 6&egrave;me &eacute;dition.</p>
<p>Il s'agit encore d'une nouvelle ``toute derni&egrave;re version
r&eacute;alis&eacute;e par Far&eacute; avant qu'un nouveau
responsable ne prenne la main''.</p>
</dd>
</dl>
<h2><a name="ss1.5">1.5 Cr&eacute;dits</a></h2>
<p>Je souhaiterais remercier les personnes suivantes:</p>
<ul>
<li><a href="mailto:buried.alive@in.mail">Linus Torvalds</a> pour
Linux</li>
<li><a href="mailto:bde@zeta.org.au">Bruce Evans</a> pour bcc
d'o&ugrave; as86 est extrait</li>
<li><a href="mailto:anakin@poboxes.com">Simon Tatham</a> et
<a href="mailto:jules@earthcorp.com">Julian Hall</a> pour
NASM.</li>
<li><a href="mailto:jim-neil@digital.net">Jim Neil</a> pour
Terse</li>
<li><a href="mailto:gregh@sunsite.unc.edu">Greg Hankins</a> pour la
coordination des HOWTOs</li>
<li><a href="mailto:raymoon@moonware.dgsys.com">Raymond Moon</a>
pour sa FAQ</li>
<li><a href="mailto:dumas@Linux.EU.Org">Eric Dumas</a> pour la
traduction initiale en fran&ccedil;ais... (l'auteur,
fran&ccedil;ais, est le premier attrist&eacute; de devoir
&eacute;crire l'original en anglais)</li>
<li><a href="mailto:paul@geeky1.ebtech.net">Paul Anderson</a> et
<a href="mailto:rahim@megsinet.net">Rahim Azizarab</a> pour m'avoir
aid&eacute;, &agrave; d&eacute;faut de reprendre le HowTo en
main.</li>
<li>toutes les personnes qui ont contribu&eacute; &agrave;
l'&eacute;criture de ce document, par leurs id&eacute;es, remarques
ou leur soutient moral.</li>
</ul>
<h2><a name="doyouneedasm"></a> <a name="s2">2. Avez-vous besoin de
l'assembleur?</a></h2>
<p>Je ne veux en aucun cas jouer les
emp&ecirc;cheurs-de-tourner-en-rond, mais voici quelques conseils
issus d'une exp&eacute;rience gagn&eacute;e &agrave; la dure.</p>
<h2><a name="ss2.1">2.1 Le Pour et le Contre</a></h2>
<h3>Les avantages de l'assembleur</h3>
<p>L'assembleur peut vous permettre de r&eacute;aliser des
op&eacute;rations tr&egrave;s bas niveau:</p>
<ul>
<li>vous pouvez acc&eacute;der aux registres et aux ports
d'entr&eacute;es/sorties sp&eacute;cifiques &agrave; votre
machine;</li>
<li>vous pouvez parfaitement contr&ocirc;ler le comportemant du
code dans des sections critiques o&ugrave; pourraient sinon advenir
un blocage du processeur ou des p&eacute;riph&eacute;riques;</li>
<li>vous pouvez sortir des conventions de production de code de
votre compilateur habituel; ce qui peut vous permettre d'effectuer
certaines optimisations (par exemple contourner les r&egrave;gles
d'allocation m&eacute;moire, g&eacute;rer manuellement le cours de
l'&eacute;x&eacute;cution, etc.);</li>
<li>acc&eacute;der &agrave; des modes de programmation non courants
de votre processeur (par exemple du code 16 bits pour
l'amor&ccedil;age ou l'interfa&ccedil;age avec le BIOS, sur les
p&eacute;c&eacute;s Intel);</li>
<li>vous pouvez construire des interfaces entre des fragments de
codes utilisant des conventions incompatibles (c'est-&agrave;-dire
produit par des compilateurs diff&eacute;rents ou
s&eacute;par&eacute;s par une interface bas-niveau);</li>
<li>vous pouvez g&eacute;n&eacute;rer un code assez rapide pour les
boucles importantes pour pallier aux d&eacute;fauts d'un
compilateur qui ne sait les optimiser (mais bon, il existe des
compilateurs optimisateurs librement disponibles!);</li>
<li>vous pouvez g&eacute;n&eacute;rer du code optimis&eacute;
"&agrave; la main" qui est plus parfaitement r&egrave;gl&eacute;
pour votre configuration mat&eacute;rielle pr&eacute;cise,
m&ecirc;me s'il ne l'est pour aucune autre configuration;</li>
<li>vous pouvez &eacute;crire du code pour le compilateur
optimisateur de votre nouveau langage. (c'est l&agrave; une
activit&eacute; &agrave; laquelle peu se livrent, et encore,
rarement.)</li>
</ul>
<h3>Les inconv&eacute;nients de l'assembleur</h3>
<p>L'assembleur est un langage tr&egrave;s bas niveau (le langage
du plus bas niveau qui soit au dessus du codage &agrave; la main de
motifs d'instructions en binaire). En cons&eacute;quence:</p>
<ul>
<li>l'&eacute;criture de code en est longue et ennuyeuse;</li>
<li>les bogues apparaissent ais&eacute;ment;</li>
<li>les bogues sont difficiles &agrave; rep&eacute;rer et
supprimer;</li>
<li>il est difficile de comprendre et de modifier du code (la
maintenance est tr&egrave;s compliqu&eacute;e);</li>
<li>le r&eacute;sultat est extr&ecirc;mement peu portable vers une
autre architecture, existante ou future;</li>
<li>votre code ne sera optimis&eacute; que une certaine
impl&eacute;mentation d'une m&ecirc;me architecture: ainsi, parmi
les plates-formes compatibles Intel, chaque r&eacute;alisation d'un
processeur et de ses variantes (largeur du bus, vitesse et taille
relatives des CPU/caches/RAM/Bus/disques, pr&eacute;sence ou non
d'un coprocesseur arithm&eacute;tique, et d'extensions MMX ou
autres) implique des techniques d'optimisations parfois
radicalement diff&eacute;rentes. Ainsi diff&egrave;rent grandement
les processeurs d&eacute;j&agrave; existant et leurs variations:
Intel 386, 486, Pentium, PPro, Pentium II; Cyrix 5x86, 6x86; AMD
K5, K6. Et ce n'est s&ucirc;rement pas termin&eacute;: de nouveaux
mod&egrave;les apparaissent continuellement, et cette liste
m&ecirc;me sera rapidement d&eacute;pass&eacute;e, sans parler du
code ``optimis&eacute;'' qui aura &eacute;t&eacute; &eacute;crit
pour l'un quelconque des processeurs ci-dessus.</li>
<li>le code peut &eacute;galement ne pas &ecirc;tre portable entre
diff&eacute;rents syst&egrave;mes d'exploitation sur la m&ecirc;me
architecture, par manque d'outils adapt&eacute;s (GAS semble
fonctionner sur toutes les plates-formes; NASM semble fonctionner
ou &ecirc;tre facilement adaptable sur toutes les plates-formes
compatibles Intel);</li>
<li>un temps incroyable de programmation sera perdu sur de menus
d&eacute;tails, plut&ocirc;t que d'&ecirc;tre efficacement
utilis&eacute; pour la conception et le choix des algorithmes
utilis&eacute;s, alors que ces derniers sont connus pour &ecirc;tre
la source de la majeure partie des gains en vitesse d'un programme.
Par exemple, un grand temps peut &ecirc;tre pass&eacute; &agrave;
grapiller quelques cycles en &eacute;crivant des routines rapides
de manipulation de cha&icirc;nes ou de listes, alors qu'un
remplacement de la structure de donn&eacute;es &agrave; un haut
niveau, par des arbres &eacute;quilibr&eacute;s et/ou des tables de
hachage permettraient imm&eacute;diatement un grand gain en
vitesse, et une parall&eacute;lisation ais&eacute;e, de
fa&ccedil;on portable permettant un entretien facile.</li>
<li>une petite modification dans la conception algorithmique d'un
programme an&eacute;antit la validit&eacute; du code assembleur si
patiemment &eacute;labor&eacute;, r&eacute;duisant les
d&eacute;veloppeurs au dilemne de sacrifier le fruit de leur
labeur, ou de s'encha&icirc;ner &agrave; une conception
algorithmique obsol&egrave;te.</li>
<li>pour des programmes qui fait des choses non point trop
&eacute;loign&eacute;es de ce que font les benchmarks standards,
les compilateurs/optimiseurs commerciaux produisent du code plus
rapide que le code assembleur &eacute;crit &agrave; la main (c'est
moins vrai sur les architectures x86 que sur les architectures
RISC, et sans doute moins vrai encore pour les compilateurs
librement disponible. Toujours est-il que pour du code C typique,
GCC est plus qu'honorable).</li>
<li>Quoi qu'il en soit, ains le dit le saige John Levine,
mod&eacute;rateur de comp.compilers, "les compilateurs rendent
ais&eacute;e l'utilisation de structures de donn&eacute;es
complexes; ils ne s'arr&ecirc;tent pas, morts d'ennui, &agrave;
mi-chemin du travail, et produisent du code de qualit&eacute; tout
&agrave; fait satisfaisante". Ils permettent &eacute;galement de
propager <em>correctement</em> les transformations du code &agrave;
travers l'ensemble du programme, aussi h&eacute;naurme soit-il, et
peuvent optimiser le code par-del&agrave; les fronti&egrave;res
entre proc&eacute;dures ou entre modules.</li>
</ul>
<h3>Affirmation</h3>
<p>En pesant le pour et le contre, on peut conclure que si
l'assembleur est parfois n&eacute;cessaire, et peut m&ecirc;me
&ecirc;tre utile dans certains cas o&ugrave; il ne l'est pas, il
vaut mieux:</p>
<ul>
<li>minimiser l'utilisation de code &eacute;crit en
assembleur;</li>
<li>encapsuler ce code dans des interfaces bien
d&eacute;finies;</li>
<li>engendrer automatiquement le code assembleur &agrave; partir de
motifs &eacute;crits dans un langage plus de haut niveau que
l'assembleur (par exemple, des macros contenant de l'assembleur
en-ligne, avec GCC);</li>
<li>utiliser des outils automatiques pour transformer ces
programmes en code assembleur;</li>
<li>faire en sorte que le code soit optimis&eacute;, si
possible;</li>
<li>utiliser toutes les techniques pr&eacute;c&eacute;dentes
&agrave; la fois, c'est-&agrave;-dire &eacute;crire ou
&eacute;tendre la passe d'optimisation d'un compilateur.</li>
</ul>
<p>M&ecirc;me dans les cas o&ugrave; l'assembleur est
n&eacute;cessaire (par exemple lors de d&eacute;veloppement d'un
syst&egrave;me d'exploitation), ce n'est qu'&agrave; petite dose,
et sans infirmer les principes ci-dessus.</p>
<p>Consultez &agrave; ce sujet les sources du noyau de Linux: vous
verrez qu'il s'y trouve juste le peu qu'il faut d'assembleur, ce
qui permet d'avoir un syst&egrave;me d'exploitation rapide, fiable,
portable et d'entretien facile. M&ecirc;me un jeu tr&egrave;s
c&eacute;l&egrave;bre comme DOOM a &eacute;t&eacute; en sa plus
grande partie &eacute;crit en C, avec une toute petite routine
d'affichage en assembleur pour acc&eacute;l&eacute;rer un peu.</p>
<h2><a name="ss2.2">2.2 Comment ne pas utiliser
l'assembleur</a></h2>
<h3>M&eacute;thode g&eacute;n&eacute;rale pour obtenir du code
efficace</h3>
<p>Comme le dit Charles Fiterman dans comp.compilers &agrave;
propos de la diff&eacute;rence entre code &eacute;crit par l'homme
ou la machine,</p>
<p>``L'homme devrait toujours gagner, et voici pourquoi:</p>
<ul>
<li>Premi&egrave;rement, l'homme &eacute;crit tout dans un langage
de haut nivrau.</li>
<li>Deuxi&egrave;mement, il mesure les temps
d'&eacute;x&eacute;cution (profiling) pour d&eacute;terminer les
endroits o&ugrave; le programme passe la majeure partie du
temps.</li>
<li>Troisi&egrave;mement, il demande au compilateur d'engendrer le
code assembleur produit pour ces petites sections de code.</li>
<li>Enfin, il effectue &agrave; la main modifications et
r&eacute;glages, &agrave; la recherche des petites
am&eacute;liorations possibles par rapport au code engendr&eacute;
par la machine.</li>
</ul>
L'homme gagne parce qu'il peut utiliser la machine.''
<h3>Langages avec des compilateurs optimisateurs</h3>
<p>Des langages comme ObjectiveCAML, SML, CommonLISP, Scheme, ADA,
Pascal, C, C++, parmi tant d'autres, ont tous des compilateurs
optimiseurs librement disponibles, qui optimiseront le gros de vos
programmes, et produiront souvent du code meilleur que de
l'assembleur fait-main, m&ecirc;me pour des boucles serr&eacute;es,
tout en vous permettant de vous concentrer sur des d&eacute;tails
haut niveau, et sans vous interdire de gagner par la m&eacute;thode
pr&eacute;c&eacute;dente quelques pourcents de performance
suppl&eacute;mentaire, une fois la phase de conception
g&eacute;n&eacute;rale termin&eacute;e. Bien s&ucirc;r, il existe
&eacute;galement des compilateurs optimiseurs commerciaux pour la
plupart de ces langages.</p>
<p>Certains langages ont des compilateurs qui produisent du code C
qui peut ensuite &ecirc;tre optimis&eacute; par un compilateur C.
C'est le cas des langages LISP, Scheme, Perl, ainsi que de nombreux
autres. La vitesse des programmes obtenus est toute &agrave; fait
satisfaisante.</p>
<h3>Proc&eacute;dure g&eacute;n&eacute;rale &agrave; suivre pour
acc&eacute;lerer votre code</h3>
<p>Pour acc&eacute;l&eacute;rer votre code, vous ne devriez traiter
que les portions d'un programme qu'un outil de mesure de temps
d'&eacute;x&eacute;cution (profiler) aura identifi&eacute; comme
&eacute;tant un goulot d'&eacute;tranglement pour la performance de
votre programme.</p>
<p>Ainsi, si vous identifiez une partie du code comme &eacute;tant
trop lente, vous devriez</p>
<ul>
<li>d'abord essayer d'utiliser un meilleur algorithme;</li>
<li>essayer de la compiler au lieu de l'interpr&eacute;ter;</li>
<li>essayer d'activer les bonnes options d'optimisation de votre
compilateur;</li>
<li>donner au compilateur des indices d'optimisation
(d&eacute;clarations de typage en LISP; utilisation des extensions
GNU avec GCC; la plupart des compilos fourmillent d'options);</li>
<li>enfin de compte seulement, se mettre &agrave; l'assembleur si
n&eacute;cessaire.</li>
</ul>
<p>Enfin, avant d'en venir &agrave; cette derni&egrave;re option,
vous devriez inspecter le code g&eacute;n&eacute;r&eacute; pour
v&eacute;rifier que le probl&egrave;me vient effectivement d'une
mauvaise g&eacute;n&eacute;ration de code, car il se peut fort bien
que ce ne soit pas le cas: le code produit par le compilateur
pourrait &ecirc;tre meilleur que celui que vous auriez
&eacute;crit, en particulier sur les architectures modernes
&agrave; pipelines multiples! Il se peut que les portions les plus
lentes de votre programme le soit pour des raisons
intrins&egrave;ques. Les plus gros probl&egrave;mes sur les
architectures modernes &agrave; processeur rapide sont dues aux
d&eacute;lais introduits par les acc&egrave;s m&eacute;moires,
manqu&eacute;s des caches et TLB, fautes de page; l'optimisation
des registres devient vaine, et il vaut mieux repenser les
structures de donn&eacute;es et l'encha&icirc;nement des routines
pour obtenir une meilleur localit&eacute; des acc&egrave;s
m&eacute;moire. Il est possible qu'une approche compl&egrave;tement
diff&eacute;rente du probl&egrave;me soit alors utile.</p>
<h3>Inspection du code produit par le compilateur</h3>
<p>Il existe de nombreuses raisons pour vouloir regarder le code
assembleur produit par le compilateur. Voici ce que vous pourrez
faire avec ce code:</p>
<ul>
<li>v&eacute;rifier si le code produit peut ou non &ecirc;tre
am&eacute;liorer avec du code assembleur &eacute;crit &agrave; la
main (ou par un r&eacute;glage diff&eacute;rent des options du
compilateur);</li>
<li>quand c'est le cas, commencer &agrave; partir de code
automatiquement engendr&eacute; et le modifier plut&ocirc;t que de
repartir de z&eacute;ro;</li>
<li>plus g&eacute;n&eacute;ralement, utilisez le code produit comme
des scions &agrave; greffer, ce qui &agrave; tout le moins vous
laisse permet d'avoir gratuitement tout le code
d'interfa&ccedil;age avec le monde ext&eacute;rieur.</li>
<li>rep&eacute;rer des bogues &eacute;ventuels dus au compilateur
lui-m&ecirc;me (esp&eacute;rons-le tr&egrave;s rare, quitte
&agrave; se restreindre &agrave; des versions ``stables'' du
compilo).</li>
</ul>
<p>La mani&egrave;re standard d'obtenir le code assembleur
g&eacute;n&eacute;r&eacute; est d'appeller le compilateur avec
l'option <code>-S</code>. Cela fonctionne avec la plupart des
compilateur Unix y compris le compilateur GNU C (GCC); mais
&agrave; vous de voir dans votre cas. Pour ce qui est de GCC, il
produira un code un peu plus compr&eacute;hensible avec l'option
<code>-fverbose-asm</code>. Bien sur, si vous souhaitez obtenir du
code assembleur optimis&eacute;, n'oubliez pas d'ajouter les
options et indices d'optimisation appropri&eacute;es!</p>
<h2><a name="s3">3. Assembleurs</a></h2>
<h2><a name="ss3.1">3.1 Assembleur en-ligne de GCC</a></h2>
<p>Le c&eacute;l&egrave;bre GNU C/C++ Compiler (GCC), est un
compilateur 32 bits optimisant situ&eacute; au coeur du projet GNU.
Il g&egrave;re assez bien les architectures x86 et permet
d'ins&eacute;rer du code assembleur &agrave; l'int&eacute;rieur de
programmes C de telle mani&egrave;re que les registres puissent
&ecirc;tre soit sp&eacute;cifi&eacute;s soit laiss&eacute; aux bons
soins de GCC. GCC fonctionne sur la plupart des plates-formes dont
Linux, *BSD, VSTa, OS/2, *DOS, Win*, etc.</p>
<h3>O&ugrave; trouver GCC</h3>
<p>Le site principal de GCC est le site FTP du projet GNU: <a href=
"ftp://prep.ai.mit.edu/pub/gnu/">ftp://prep.ai.mit.edu/pub/gnu/</a>
On y trouve &eacute;galement toutes les applications provenant du
projet GNU. Des versions configur&eacute;es ou
pr&eacute;compil&eacute;es pour Linux sont disponibles sur <a href=
"ftp://sunsite.unc.edu/pub/Linux/GCC/">ftp://sunsite.unc.edu/pub/Linux/GCC/</a>.
Il existe un grand nombre de miroirs FTP des deux sites partout de
par le monde, aussi bien que des copies sur CD-ROM.</p>
<p>Le groupe de d&eacute;veloppement de GCC s'est r&eacute;cemment
scind&eacute; en deux; pour plus d'informations sur la version
exp&eacute;rimentale, egcs, voir <a href=
"http://www.cygnus.com/egcs/">http://www.cygnus.com/egcs/</a></p>
<p>Les sources adapt&eacute;s &agrave; votre syst&egrave;me
d'exploitation pr&eacute;f&eacute;r&eacute; ainsi que les binaires
pr&eacute;compil&eacute;s peuvent &ecirc;tre trouv&eacute;s sur les
sites FTP courants.</p>
<p>Le portage le plus c&eacute;l&egrave;bre de GCC pour DOS est
DJGPP et il peut &ecirc;tre trouv&eacute; dans le r&eacute;pertoire
du m&ecirc;me nom sur les sites ftp. Voir:</p>
<p><a href=
"http://www.delorie.com/djgpp/">http://www.delorie.com/djgpp/</a></p>
<p>Il existe &eacute;galement un portage de GCC pour OS/2
appel&eacute; EMX qui fonctionne &eacute;galement sous DOS et
inclut un grand nombre de routines d'&eacute;mulation Unix. Voir
les sites</p>
<p><a href=
"http://www.leo.org/pub/comp/os/os2/gnu/emx+gcc/">http://www.leo.org/pub/comp/os/os2/gnu/emx+gcc/</a></p>
<p><a href=
"http://warp.eecs.berkeley.edu/os2/software/shareware/emx.html">http://warp.eecs.berkeley.edu/os2/software/shareware/emx.html</a></p>
<p><a href=
"ftp://ftp-os2.cdrom.com/pub/os2/emx09c/">ftp://ftp-os2.cdrom.com/pub/os2/emx09c/</a></p>
<h3>O&ugrave; trouver de la documentation sur l'assembleur en ligne
avec GCC?</h3>
<p>La document de GCC inclus les fichiers de documentation au
format texinfo. Vous pouvez les compiler avec TeX et les imprimer,
ou les convertir au format .info et les parcourir interactivement
avec emacs, ou encore les convertir au format HTML, ou en &agrave;
peu pr&egrave;s n'importe quel format (avec les outils
ad&eacute;quats). Les fichiers .info sont
g&eacute;n&eacute;ralement install&eacute;s en m&ecirc;me temps que
GCC.</p>
<p>La section &agrave; consulter est <code>C Extensions::Extended
Asm::</code></p>
<p>La section <code>Invoking GCC::Submodel Options::i386
Options::</code> peut &eacute;galement vous aider. En particulier,
elle donne les noms de contraintes pour les registres du i386:
abcdSDB correspondent respectivement &agrave; <code>%eax</code>,
<code>%ebx</code>, <code>%ecx</code>, <code>%edx</code>,
<code>%esi</code>, <code>%edi</code>, <code>%ebp</code> (aucune
lettre pour <code>%esp</code>).</p>
<p>Le site "DJGPP Games resource" (qui n'est pas
r&eacute;serv&eacute; aux seuls d&eacute;veloppeurs de jeux)
poss&egrave;de une page particuli&egrave;re sur l'assembleur:</p>
<p><a href=
"http://www.rt66.com/~brennan/djgpp/djgpp_asm.html">http://www.rt66.com/~brennan/djgpp/djgpp_asm.html</a></p>
<p>Enfin, il existe une page de la Toile appel&eacute;e "DJGPP
Quick ASM Programming Guide", contenant des URL sur des FAQ, la
syntaxe assembleur AT&amp;T x86, des informations sur l'assembleur
en ligne, et la conversion des fichiers .obj/.lib:</p>
<p><a href=
"http://remus.rutgers.edu/~avly/djasm.html">http://remus.rutgers.edu/~avly/djasm.html</a></p>
<p>GCC soutraite l'assemblage proprement dit &agrave; GAS et suit
donc sa syntaxe (voir plus bas), cela implique que l'assembleur en
ligne doit utiliser des caract&egrave;res pourcents entre
apostrophes pour qu'ils soient pass&eacute;s &agrave; GAS. Voir la
section d&eacute;di&eacute;e &agrave; GAS.</p>
<p>Vous trouverez un <em>grand</em> nombre d'exemples instructifs
dans le r&eacute;pertoire <code>linux/include/asm-i386/</code> des
sources de Linux.</p>
<h3>Appeller GCC pour obtenir du code assembleur en ligne
correcte?</h3>
<p>Assurez-vous d'appeller gcc avec l'option <code>-O</code> (ou
<code>-O2</code>, <code>-O3</code>, etc) pour activer les
optimisations et l'assembleur en ligne. Si vous ne le fa&icirc;tes
pas, votre code pourra compiler mais ne pas s'ex&eacute;cuter
correctement!! En fait (merci &agrave; Tim Potter,
timbo@moshpit.air.net.au), il suffit d'utiliser l'option
<code>-fasm</code>, faisant partie de toutes les
fonctionnalit&eacute;s activ&eacute;es par l'option
<code>-O</code>. Donc si vous avez des probl&egrave;mes en raison
d'optimisations bogu&eacute;es dans votre impl&eacute;mentation de
gcc, vous pouvez toujours utiliser l'assembleur en ligne. De
m&ecirc;me, utilisez l'option <code>-fno-asm</code> pour
d&eacute;sactiver l'assembleur en ligne (on peut se demander
pourquoi?).</p>
<p>Plus g&eacute;n&eacute;ralement, les bonnes options de
compilation &agrave; utiliser avec gcc sur les plates-formes x86
sont</p>
<hr>
<pre>
        gcc -O2 -fomit-frame-pointer -m386 -Wall
</pre>
<hr>
<p><code>-O2</code> est le bon niveau d'optimisation. Les
optimisations sup&eacute;rieures g&eacute;n&egrave;rent un code un
peu plus important, mais tr&egrave;s l&eacute;g&egrave;rement plus
rapide. De telles sur-optimisations peuvent &ecirc;tre utiles que
dans le cas d'optimisations de boucles que vous pouvez toujours
r&eacute;aliser en assembleur. Si vous avez besoin de faire ce
genre de choses, ne le fa&icirc;tes que pour les routines qui en
ont besoin.</p>
<p><code>-fomit-frame-pointer</code> permet au code
g&eacute;n&eacute;r&eacute; de se passer de la gestion inutile des
pointeurs de fen&ecirc;tre, ce qui rend le code plus petit plus
rapide et lib&egrave;re un registre pour de plus amples
optimisations. Cette option exclue l'utilisation des outils de
d&eacute;boggage (<code>gdb</code>), mais lorsque vous les
utilisez, la taille et la vitesse importent peu.</p>
<p><code>-m386</code> g&eacute;n&egrave;re un code plus compacte
sans ralentissement notable, (moins de code signifie
&eacute;galement mois d'entr&eacute;es/sorties sur disque et donc
une ex&eacute;cution plus rapide). Vous pouvez &eacute;galement
utiliser l'option -mpentium sur la version GCC g&eacute;rant
l'optimisation pour ce processeur.</p>
<p><code>-Wall</code> active toutes les mises-en-garde (warning) et
vous &eacute;vite de nombreuses erreurs stupides et
&eacute;videntes.</p>
<p>Pour optimiser encore plus, vous pouvez utiliser l'option
<code>-mregparm=2</code> et/ou les attributs de fonctions qui
peuvent &ecirc;tre utilis&eacute;s mais ils peuvent dans certains
cas poser de nombreux probl&egrave;mes lors de l'&eacute;dition de
liens avec du code externe (notamment les biblioth&egrave;ques
partag&eacute;es)...</p>
<p>Notez que vous pouvez ajoutez ces options aux options
utilis&eacute;es par d&eacute;faut sur votre syst&egrave;me en
&eacute;ditant le fichier
<code>/usr/lib/gcc-lib/i486-linux/2.7.2.3/specs</code> (cependant,
ne rajoutez pas <code>-Wall</code> &agrave; ces options).</p>
<h2><a name="ss3.2">3.2 GAS</a></h2>
<p>GAS est l'assembleur GNU, utilis&eacute; par gcc.</p>
<h3>O&ugrave; le trouver?</h3>
<p>Au m&ecirc;me endroit o&ugrave; vous avez trouv&eacute; gcc,
dans le paquetage binutils.</p>
<h3>Qu'est-ce que la syntaxe AT&amp;T</h3>
<p>Comme GAS a &eacute;t&eacute; invent&eacute; pour supporter un
compilateur 32 bits sous unix, il utilise la syntaxe standard
"AT&amp;T", qui ressemblent assez &agrave; l'assembleur m68k. La
syntaxe n'est ni pire, ni meilleur que la syntaxe "Intel". Elle est
juste diff&eacute;rente. Lorsque vous aurez l'habitude de vous en
servir, vous la trouverez plus r&eacute;guli&egrave;re que la
syntaxe Intel, quoique que l&eacute;g&egrave;rement plus ennuyeuse
aussi.</p>
<p>Voici les points les plus importants &agrave; propos de la
syntaxe de GAS:</p>
<ul>
<li>Les noms de registres sont pr&eacute;fix&eacute;s avec
<code>%</code>, de fa&ccedil;on que les registres sont
<code>%eax</code>, <code>%dl</code> et consorts au lieu de juste
<code>eax</code>, <code>dl</code>, etc. Ceci rend possible
l'inclusion directe de noms de symboles externes C sans risque de
confusion, ou de n&eacute;cessit&eacute; de pr&eacute;fixes _.</li>
<li>L'ordre des op&eacute;randes est source(s) d'abord, destination
en dernier, &agrave; l'oppos&eacute; de la convention d'intel
consistant &agrave; mettre la destination en premier, les source(s)
ensuite. Ainsi, ce qui en syntaxe intel s'&eacute;crit <code>mov
ax,dx</code> (affecter au registre <code>ax</code> le contentu du
registre <code>dx</code>) s'&eacute;crira en syntaxe att <code>mov
%dx, %ax</code>.</li>
<li>La longueur des op&eacute;randes est sp&eacute;cifi&eacute;e
comme suffixe du nom d'instruction. Le suffixe est <code>b</code>
pour un octet (8 bit), <code>w</code> pour un mot (16 bit), et
<code>l</code> pour un mot long (32 bit). Par exemple, la syntaxe
correcte pour l'instruction ci-dessus aurait d&ucirc; &ecirc;tre
<code>movw %dx,%ax</code>. Toutefois, gas n'est pas trop aussi
strict que la syntaxe att l'exige, et le suffixe est optionel quand
la longueur peut &ecirc;tre devin&eacute;e gr&acirc;ce aux
op&eacute;randes qui sont des registres, la taille par
d&eacute;faut &eacute;tant 32 bit (avec une mise en garde quand on
y fait appel).</li>
<li>Les op&eacute;randes immediates sont marqu&eacute;s d'un
pr&eacute;fixe <code>$</code>, comme dans <code>addl $5,%eax</code>
(ajouter la valeur longue imm&eacute;diate 5 au registre
<code>%eax</code>).</li>
<li>L'absence de pr&eacute;fixe &agrave; une op&eacute;rande
indique une adresse m&eacute;moire; ainsi <code>movl
$foo,%eax</code> met l'<em>adresse</em> de la variable
<code>foo</code> dans le registre <code>%eax</code>, tandis que
<code>movl foo,%eax</code> met le <code>contenu</code> de la
variable <code>foo</code> dans le registre <code>%eax</code>.</li>
<li>L'indexation ou l'indirection se fait en mettant entre
parenth&egrave;ses le registre d'index ou la case m&eacute;moire
contenant l'indirection, comme dans <code>testb
$0x80,17(%ebp)</code> (tester le bit de poids fort de l'octet au
d&eacute;placement 17 apr&egrave;s la case point&eacute;e par
<code>%ebp</code>).</li>
</ul>
<p>Un programme existe pour vous aider &agrave; convertir des
programmes &eacute;crits avec la syntaxe TASM en syntaxe AT&amp;T.
Voir</p>
<p><a href=
"ftp://x2ftp.oulu.fi/pub/msdos/programming/convert/ta2asv08.zip">ftp://x2ftp.oulu.fi/pub/msdos/programming/convert/ta2asv08.zip</a></p>
<p>GAS poss&egrave;de une documentation compl&egrave;te au format
TeXinfo, qui est distribu&eacute;e entre autre avec les sources.
Vous pouvez parcourir les pages .info qui en sont extraites avec
Emacs. Il y avait aussi un fichier nomm&eacute; gas.doc ou as.doc
disponible autour des sources de GAS, mais il a &eacute;t&eacute;
fusionn&eacute; avec la documentation TeXinfo. Bien s&ucirc;r, en
cas de doute, l'ultime documentation est constitu&eacute;e par les
sources eux-m&ecirc;mes! Une section qui vous int&eacute;ressera
particuli&egrave;rement est <code>Machine
Dependencies::i386-Dependent::</code></p>
<p>Les sources de Linux dont un bon exemple: regardez dans le
r&eacute;pertoire linux/arch/i386 les fichiers suivants:
<code>kernel/*.S, boot/compressed/*.S, mathemu/*.S</code></p>
<p>Si vous codez ce genre de chose, un paquetage de thread, etc
vous devriez regarder d'autres langages (OCaml, gforth, etc), ou
des paquetages sur les thread (QuickThreads, pthreads MIT,
LinuxThreads, etc).</p>
<p>Enfin g&eacute;n&eacute;rer &agrave; partir d'un programme C du
code assembleur peut vous montrer le genre d'instructions que vous
voulez. Consultez la section <a href="#doyouneedasm">Avez-vous
besoin de l'assembleur?</a> au d&eacute;but de ce document.</p>
<h3>mode 16 bits limit&eacute;</h3>
<p>GAS est un assembleur 32 bits, con&ccedil;u pour assembler le
code produit par un compilateur 32 bits. Il ne reconna&icirc;t que
d'une mani&egrave;re limit&eacute; le mode 16 bits du i386, en
ajoutant des pr&eacute;fixes 32 bits aux instructions; vous
&eacute;crivez donc en r&eacute;alit&eacute; du code 32 bits, qui
s'ex&eacute;cute en mode 16 bits sur un processeur 32 bits. Dans
les deux modes, il g&egrave;re les registres 16 bits, mais pas
l'adressage 16 bits. Utilisez les instructions <code>.code16</code>
et <code>.code32</code> pour basculer d'un mode &agrave; l'autre.
Notez que l'instruction assembleur en ligne
<code>asm(".code16\n")</code> autorisera gcc &agrave;
g&eacute;n&eacute;rer du code 32 bits qui fonctionnera en mode
r&eacute;&eacute;l!</p>
<p>Le code n&eacute;cessaire pour que GAS g&egrave;re le mode 16
bits aurait &eacute;t&eacute; ajout&eacute; par Bryan Ford
(&agrave; confirmer?). Toutefois, ce code n'est pr&eacute;sent dans
aucune distribution de GAS que j'ai essay&eacute;e (jusqu'&agrave;
binutils-2.8.1.x) ... plus d'informations &agrave; ce sujet
seraient les bienvenues dans ce HowTo.</p>
<p>Une solution bon march&eacute; pour ins&eacute;rer quelques
instructions 16-bit non reconnues pas GAS consiste &agrave;
d&eacute;finir des macros (voir plus bas) qui produisent
directement du code binaire (avec <code>.byte</code>), et ce
uniquement pour les rares instructions 16 bits dont vous avez
besoin (quasiment aucunes, si vous utilisez le <code>.code16</code>
pr&eacute;c&eacute;dement d&eacute;crit, et pouvez vous permettre
de supposer que le code fonctionnera sur un processeur 32 bits).
Pour obtenir le syst&egrave;me de codage correct, vous pouvez vous
inspirer des assembleurs 16 bits.</p>
<h2><a name="ss3.3">3.3 GASP</a></h2>
<p>GASP est un pr&eacute;processeur pour GAS. Il ajoute des macros
et une syntaxe plus souple &agrave; GAS.</p>
<h3>O&ugrave; trouver gasp?</h3>
<p>gasp est livr&eacute; avec gas dans le paquetage binutils
GNU.</p>
<h3>Comment il fonctionne?</h3>
<p>Cela fonctionne comme un filtre, tout comme cpp et ses
variantes. Je ne connais pas les d&eacute;tails, mais il est
livr&eacute; avec sa propre documentation texinfo, donc
consultez-la, imprimez-la, assimilez-la. La combinaison GAS/GASP me
semble &ecirc;tre un macro-assembleur standard.</p>
<h2><a name="ss3.4">3.4 NASM</a></h2>
<p>Du projet Netwide Assembler est issu encore un autre assembleur,
&eacute;crit en C, qui devrait &ecirc;tre assez modulaire pour
supporter toutes les syntaxes connues et tous les formats objets
existants.</p>
<h3>O&ugrave; trouver NASM?</h3>
<p><a href=
"http://www.cryogen.com/Nasm">http://www.cryogen.com/Nasm</a></p>
<p>Les versions binaires se trouvent sur votre miroir sunsite
habituel dans le r&eacute;pertoire <code>devel/lang/asm/</code>. Il
devrait &eacute;galement &ecirc;tre disponible sous forme d'archive
.rpm ou .deb parmi les contributions &agrave; votre distribution
pr&eacute;f&eacute;r&eacute;e RedHat ou Debian.</p>
<h3>Son r&ocirc;le</h3>
<p>Au moment de l'&eacute;criture de ce HOWTO, NASM en est &agrave;
la version 0.96.</p>
<p>La syntaxe est &agrave; la Intel. Une gestion de macros est
int&eacute;gr&eacute;e.</p>
<p>Les formats objets reconnus sont <code>bin</code>,
<code>aout</code>, <code>coff</code>, <code>elf</code>,
<code>as86</code>, (DOS) <code>obj</code>, <code>win32</code>, et
<code>rdf</code> (leur propre format).</p>
<p>NASM peut &ecirc;tre utilis&eacute;e comme assembleur pour le
compilateur libre LCC.</p>
<p>Comme NASM &eacute;volue rapidement, ce HowTo peut ne pas
&ecirc;tre &agrave; jour &agrave; son sujet. A moins que vous
n'utilisiez BCC comme compilateur 16 bit (ce qui d&eacute;passe le
cadre de ce document), vous devriez utiliser NASM plut&ocirc;t que
AS86 ou MASM, car c'est un logiciel libre avec un excellent service
apr&egrave;s-don, qui tourne sur toutes plateformes logicielles et
mat&eacute;rielles.</p>
<p>Note: NASM est &eacute;galement livr&eacute; avec un
d&eacute;sassembleur, NDISASM.</p>
<p>Son analyseur "grammatical", &eacute;crit &agrave; la main, le
rend beaucoup plus rapide que GAS; en contrepartie, il ne
reconna&icirc;t qu'une architecture, en comparaison de la
pl&eacute;thore d'architectures reconnues par GAS. Pour les
plates-formes x86, NASM semble &ecirc;tre un choix judicieux.</p>
<h2><a name="ss3.5">3.5 AS86</a></h2>
<p>AS86 est un assembleur 80x86, &agrave; la fois 16 et 32 bits,
faisant partie du compilateur C de Bruce Evans (BCC). Il
poss&egrave;de une syntaxe &agrave; la Intel.</p>
<h3>Where to get AS86</h3>
<p>Une version compl&egrave;tement d&eacute;pass&eacute;e de AS86
est diffus&eacute;e par HJLu juste pour compiler le noyau Linux,
dans un paquetage du nom de bin86 (actuellement version 0.4)
disponible dans le r&eacute;pertoire GCC des sites FTP Linux. Je
d&eacute;conseille son utilisation pour toute autre chose que
compiler Linux. Cette version ne reconna&icirc;t qu'un format de
fichiers minix modifi&eacute;, que ne reconnaissent ni les binutils
GNU ni aucun autre produit. Il poss&egrave;de de plus certains
bogues en mode 32 bits. Ne vous en servez donc vraiment que pour
compiler Linux.</p>
<p>Les versions les plus r&eacute;centes de Bruce Evans
(bde@zeta.org.au) est diffus&eacute;e avec la distribution FreeBSD.
Enfin, elles l'&eacute;taient! Je n'ai pas pu trouver les sources
dans la distribution 2.1. Toutefois, vous pouvez trouver les
sources dans</p>
<p><a href=
"http:///www.eleves.ens.fr:8080/home/rideau/files/bcc-95.3.12.src.tgz">
http:///www.eleves.ens.fr:8080/home/rideau/files/bcc-95.3.12.src.tgz</a></p>
<p>Le projet Linux/8086 (&eacute;galement appel&eacute; ELKS) s'est
d'une certaine mani&egrave;re charg&eacute;e de maintenir bcc (mais
je ne crois pas qu'ils aient inclus les patches 32 bits). Voir les
sites <a href=
"http://www.linux.org.uk/Linux8086.html">http://www.linux.org.uk/Linux8086.html</a>
et <a href="ftp://linux.mit.edu/">ftp://linux.mit.edu/</a>.</p>
<p>Entre autres choses, ces versions plus r&eacute;centes, &agrave;
la diff&eacute;rence de celle de HJLu, g&egrave;rent le format
a.out de Linux; vous pouvez donc effectuer des &eacute;ditions de
liens avec des programmes Linux, et/ou utiliser les outils
habituels provenant du paquetage binutils pour manipuler vos
donn&eacute;es. Cette version peut co-exister sans probl&egrave;me
avec les versions pr&eacute;c&eacute;dentes (voir la question
&agrave; ce sujet un peu plus loin).</p>
<p>La version du 12 mars 1995 de BCC ainsi que les
pr&eacute;c&eacute;dentes a un probl&egrave;me qui provoque la
g&eacute;n&eacute;ration de toutes les op&eacute;rations
d'empilement/d&eacute;pilement de segments en 16 bits, ce qui est
particuli&egrave;rement ennuyant lorsque vous d&eacute;veloppez en
mode 32 bits. Un patch est diffus&eacute; par le projet Tunes</p>
<p><a href=
"http://www.eleves.ens.fr:8080/home/rideau/Tunes/">http://www.eleves.ens.fr:8080/home/rideau/Tunes/</a></p>
<p>&agrave; partir du lien suivant:
<code>files/tgz/tunes.0.0.0.25.src.tgz</code> ou dans le
r&eacute;pertoire <code>LLL/i386/</code>.</p>
<p>Le patch peut &eacute;galement &ecirc;tre directement
r&eacute;cup&eacute;r&eacute; sur</p>
<p><a href=
"http://www.eleves.ens.fr:8080/home/rideau/files/as86.bcc.patch.gz">
http://www.eleves.ens.fr:8080/home/rideau/files/as86.bcc.patch.gz</a></p>
<p>Bruce Evans a accept&eacute; ce patch, donc si une version plus
r&eacute;cente de BCC existe, le patch devrait avoir
&eacute;t&eacute; int&eacute;gr&eacute;...</p>
<h3>Comme appeller l'assembleur?</h3>
<p>Voici l'entr&eacute;e d'un Makefile GNU pour utiliser bcc pour
transformer un fichier assembleur <code>.s</code> &agrave; la fois
en un objet a.out GNU <code>.o</code> et un listing
<code>.l</code>:</p>
<hr>
<pre>
%.o %.l:        %.s
        bcc -3 -G -c -A-d -A-l -A$*.l -o $*.o $&lt;
</pre>
<hr>
<p>Supprimez <code>%.l</code>, <code>-A-l</code>, et
<code>-A$*.l</code>, si vous ne voulez pas avoir de listing. Si
vous souhaitez obtenir autre chose que du a.out GNU, consultez la
documentation de bcc concernant les autres formats reconnus et/ou
utilisez le programme objcopy du paquetage binutils.</p>
<h3>O&ugrave; trouver de la documentation</h3>
<p>Les documentations se trouvent dans le paquetage bcc. Des pages
de manuel sont &eacute;galement disponibles quelque part sur le
site de FreeBSD. Dans le doute, les sources sont assez souvent une
bonne documentation: ce n'est pas tr&egrave;s comment&eacute; mais
le style de programmation est tr&egrave;s simple. Vous pouvez
essayer de voir comment as86 est utilis&eacute; dans Tunes
0.0.0.25...</p>
<h3>Que faire si je ne peux plus compiler Linux avec cette nouvelle
version</h3>
<p>Linus est submerg&eacute; par le courrier &eacute;lectronique et
mon patch pour compiler Linux avec un as86 a.out n'a pas d&ucirc;
lui parvenir (!). Peu importe: conservez le as86 provenant du
paquetage bin86 dans le r&eacute;pertoire /usr/bin, et laissez bcc
installer le bon as86 en tant que /usr/local/libexec/i386/bcc/as
comme que de droit. Vous n'aurez jamais besoin d'appeler
explicitement ce dernier, car bcc se charge tr&egrave;s bien de
tout, y compris la conversion en a.out Linux, lorsqu'il est
appel&eacute; avec les bonnes options. Assemblez les fichiers
uniquement en passant par bcc, et non pas en appelant as86
directement.</p>
<h2><a name="ss3.6">3.6 Autres assembleurs</a></h2>
<p>Il s'agit d'autres possibilit&eacute;s, qui sortent de la voie
ordinaire, pour le cas o&ugrave; les solutions
pr&eacute;c&eacute;dentes ne vous conviennent pas (mais je voudrais
bien savoir pourquoi?), que je ne recommande pas dans les cas
habituels, mais qui peuvent se montrer fort utiles si l'assembleur
doit faire partie int&eacute;grante du logiciel que vous concevez
(par exemple un syst&egrave;me d'exploitation ou un environnement
de d&eacute;veloppement).</p>
<h3>L'assembleur de Win32Forth</h3>
<p>Win32Forth est un syst&egrave;me ANS FORTH 32 bit <em>libre</em>
qui fonctionne sous Win32s, Win95, Win/NT. Il comprend un
assembleur 32 bit libre (sous forme pr&eacute;fixe ou postfixe)
int&eacute;gr&eacute;e au langage FORTH. Le traitement des macro
est effectu&eacute; en utilisant toute la puissance du langage
r&eacute;flexif FORTH. Toutefois, le seul contexte d'entr&eacute;e
et sortie reconnu actuellement est Win32For lui-m&ecirc;me (aucune
possibilit&eacute; d'obtenir un fichier objet, mais vous pouvez
toujours l'ajouter par vous-m&ecirc;me, bien s&ucirc;r). Vous
pouvez trouver Win32For &agrave; l'adresse suivante: <a href=
"ftp://ftp.forth.org/pub/Forth/win32for/">ftp://ftp.forth.org/pub/Forth/win32for/</a></p>
<h3>Terse</h3>
<p>Terse est un outil de programmation qui fournit <em>LA</em>
syntaxe assembleur la plus compacte pour la famille des processeur
x86! Voir le site <a href=
"http://www.terse.com">http://www.terse.com</a>. Ce n'est cependant
pas un logiciel libre. Il y aurait eu un clone libre quelque part,
abandonn&eacute; &agrave; la suite de mensong&egrave;res
all&eacute;gations de droits sur la syntaxe, que je vous invite
&agrave; ressusciter si la syntaxe vous int&eacute;resse.</p>
<h3>Assembleurs non libres et/ou non 32 bits</h3>
<p>Vous trouverez un peu plus d'informations sur eux, ainsi que sur
les bases de la programmation assembleur sur x86, dans la FAQ de
Raymond Moon pour le forum comp.lang.asm.x86. Voir <a href=
"http://www2.dgsys.com/~raymoon/faq/asmfaq.zip">http://www2.dgsys.com/~raymoon/faq/asmfaq.zip</a></p>
<p>Remarquez que tous les assembleurs DOS devraient fonctionner
avec l'&eacute;mulateur DOS de Linux ainsi qu'avec d'autres
&eacute;mulateurs du m&ecirc;me genre. Aussi, si vous en
poss&eacute;dez un, vous pouvez toujours l'utiliser &agrave;
l'int&eacute;rieur d'un vrai syst&egrave;me d'exploitation. Les
assembleurs sous DOS assez r&eacute;cents g&egrave;rent
&eacute;galement les formats de fichiers objets COFF et/ou des
formats g&eacute;r&eacute;s par la biblioth&egrave;que GNU BFD de
telle mani&egrave;re que vous pouvez les utiliser en conjonction
avec les outils 32 bits libres, en utilisant le programme GNU
objcopy (du paquetage binutils) comme un filtre de conversion.</p>
<h2><a name="s4">4.
M&eacute;ta-programmation/macro-traitement</a></h2>
<p>La programmation en assembleur est particuli&egrave;rement
p&eacute;nible si ce n'est pour certaines parties critiques des
programmes.</p>
<p>Pour travail donn&eacute;, il faut l'outil appropri&eacute;; ne
choisissez donc pas l'assembleur lorsqu'il ne correspond pas au
probl&egrave;me &agrave; r&eacute;soudre: C, OCAML, perl, Scheme
peuvent &ecirc;tre un meilleur choix dans la plupart des cas.</p>
<p>Toutefois, il y a certains cas o&ugrave; ces outils n'ont pas un
contr&ocirc;le suffisamment fin sur la machine, et o&ugrave;
l'assembleur est utile ou n&eacute;cessaire. Dans ces cas, vous
appr&eacute;cierez un syst&egrave;me de programmation par macros,
ou un syst&egrave;me de m&eacute;ta-programmation, qui permet aux
motifs r&eacute;p&eacute;titifs d'&ecirc;tre factoris&eacute;s
chacun en une seule d&eacute;finition ind&eacute;finiment
r&eacute;utilisable. Cela permet une programmation plus s&ucirc;re,
une propagation automatique des modifications desdits motifs, etc.
Un assembleur de base souvent ne suffit pas, m&ecirc;me pour
n'&eacute;crire que de petites routines &agrave; lier &agrave; du
code C.</p>
<h2><a name="ss4.1">4.1 Description</a></h2>
<p>Oui, je sais que cette partie peut manquer d'informations utiles
&agrave; jour. Vous &ecirc;tes libres de me faire part des
d&eacute;couvertes que vous auriez d&ucirc; faire &agrave; la
dure...</p>
<h3>GCC</h3>
<p>GCC vous permet (et vous oblige) de sp&eacute;cifier les
contraintes entre registres assembleurs et objets C, pour que le
compilateur puisse interfacer le code assembleur avec le code
produit par l'optimiseur. Le code assembleur en ligne est donc
constitu&eacute; de motifs, et pas forc&eacute;ment de code
exact.</p>
<p>Et puis, vous pouvez mettre du code assembleur dans des
macro-d&eacute;finitions de CPP ou des fonctions "en-ligne"
(inline), de telle mani&egrave;re que tout le monde puisse les
utiliser comme n'importe quelle fonction ou macro C. Les fonctions
en ligne ressemblent &eacute;norm&eacute;ment aux macros mais sont
parfois plus propres &agrave; utiliser. M&eacute;fiez-vous car dans
tous ces cas, le code sera dupliqu&eacute;, et donc seules les
&eacute;tiquettes locales (comme <code>1:</code>) devraient
&ecirc;tre d&eacute;finies dans ce code assembleur. Toutefois, une
macro devrait permettre de passer en param&egrave;tre le nom
&eacute;ventuellement n&eacute;cessaire d'une &eacute;tiquette
d&eacute;finie non localement (ou sinon, utilisez des
m&eacute;thodes suppl&eacute;mentaires de
m&eacute;ta-programmation). Notez &eacute;galement que propager du
code assembleur en-ligne r&eacute;pandra les bogues potentiels
qu'il contiendrait, aussi, faites doublement attention &agrave;
donner &agrave; GCC des contraintes correctes.</p>
<p>Enfin, le langage C lui-m&ecirc;me peut &ecirc;tre
consid&eacute;r&eacute; comme &eacute;tant une bonne abstraction de
la programmation assembleur, qui devrait vous &eacute;viter la
plupart des difficult&eacute;s de la programmation assembleur.</p>
<p>M&eacute;fiez-vous des optimisations consistant &agrave; passer
les arguments en utilisant les registres: cela interdit aux
fonctions concern&eacute;es d'&ecirc;tre appel&eacute;es par des
routines exterieurs (en particulier celles &eacute;crites &agrave;
la main en assembleur) d'une mani&egrave;re standard; l'attribut
asmlinkage devrait emp&ecirc;cher des routines donn&eacute;es
d'&ecirc;tre concern&eacute;es par de telles options
d'optimisation. Voir les sources du noyau Linux pour avoir des
exemples.</p>
<h3>GAS</h3>
<p>GAS a quelques menues fonctionnalit&eacute; pour les macro,
d&eacute;taill&eacute;es dans la documentation TeXinfo. De plus</p>
<p>J'ai entendu dire que les versions r&eacute;centes en seront
dot&eacute;es... voir les fichiers TeXinfo). De plus, tandis que
GCC reconna&icirc;t les fichiers en .s comme de l'assembleur
&agrave; envoyer dans GAS, il reconna&icirc;t aussi les fichiers en
.S comme devant &ecirc;tre filtrer &agrave; travers CPP avant
d'&ecirc;tre envoyer &agrave; GAS. Au risque de me
r&eacute;p&eacute;ter, je vous convie &agrave; consulter les
sources du noyau Linux.</p>
<h3>GASP</h3>
<p>Il ajoute toutes les fonctionnalit&eacute;s habituelles de macro
&agrave; GAS. Voir sa documentation sous forme texinfo.</p>
<h3>NASM</h3>
<p>NASM poss&egrave;de aussi son syst&egrave;me de macros.
Consultez sa documentation. Si vous avez quelqu'id&eacute;e
lumineuse, contactez les auteurs, &eacute;tant donn&eacute; qu'ils
sont en train de d&eacute;velopper NASM activement. Pendant ce
m&ecirc;me temps, lisez la partie sur les filtres externes un peu
plus loin.</p>
<h3>AS86</h3>
<p>Il poss&egrave;de un syst&egrave;me simple de macros, mais je
n'ai pas pu trouver de documentation. Cependant, les sources sont
d'une approche particuli&egrave;rement ais&eacute;e, donc si vous
&ecirc;tes int&eacute;ress&eacute; pour en savoir plus, vous
devriez pouvoir les comprendre sans probl&egrave;me. Si vous avez
besoin d'un peu plus que des bases, vous devriez utiliser un filtre
externe (voir un peu plus loin).</p>
<h3>Autres assembleurs</h3>
<ul>
<li>Win32FORTH: CODE et END-CODE sont des macros qui ne basculent
pas du mode interpr&eacute;tation au mode compilation; vous aurez
donc acc&egrave;s &agrave; toute la puissance du FORTH lors de
l'assemblage.</li>
<li>Tunes: cela ne fonctionne pas encore, mais le langage Scheme
est un langage de tr&egrave;s haut niveau qui permet une
m&eacute;ta-programmation arbitraire.</li>
</ul>
<h2><a name="ss4.2">4.2 Filtres externes</a></h2>
<p>Quelque soit la gestion des macros de votre assembleur, ou
quelque soit le langage que vous utilisez (m&ecirc;me le C), si le
langage n'est pas assez expressif pour vous, vous pouvez faire
passer vos fichier &agrave; travers un filtre externe gr&acirc;ce
&agrave; une r&egrave;gle comme suit dans votre Makefile:</p>
<hr>
<pre>
%.s:    %.S autres_d&eacute;pendances
        $(FILTER) $(FILTER_OPTIONS) &lt; $&lt; &gt; $@
</pre>
<hr>
<h3>CPP</h3>
<p>CPP n'est vraiment pas tr&egrave;s expressif, mais il suffit
pour les choses faciles, et il est appel&eacute; d'une
mani&egrave;re transparente par GCC.</p>
<p>Comme exemple de limitation, vous ne pouvez pas d&eacute;clarer
d'objet de fa&ccedil;on &agrave; ce qu'un destructeur soit
automatiquement appel&eacute; &agrave; la fin du bloc ayant
d&eacute;clar&eacute; l'objet. Vous n'avez pas de diversions ou de
gestion de port&eacute;e des variables, etc.</p>
<p>CPP est livr&eacute; avec tout compilateur C. Si vous pouvez
faire sans, n'allez pas chercher CPP (bien que je me demande
comment vous pouvez faire).</p>
<h3>M4</h3>
<p>M4 vous donne la pleine puissance du macro-traitement, avec un
langage Turing-&eacute;quivalent, r&eacute;cursivit&eacute;,
expressions r&eacute;guli&egrave;res, etc. Vous pouvez faire avec
tout ce que cpp ne peut faire.</p>
<p>Voir macro4th/This4th que l'on trouve sur <a href=
"ftp://ftp.forth.org/pub/Forth/">ftp://ftp.forth.org/pub/Forth/</a>
dans Reviewed/ ANS/ (?), ou les sources de Tunes 0.0.0.25 comme
exemple de programmation avanc&eacute;e en utilisant m4.</p>
<p>Toutefois, le syst&egrave;me de citation est tr&egrave;s
p&eacute;nible &agrave; utiliser et vous oblige &agrave; utiliser
un style de programmation par fonctions r&eacute;cursives avec
passage explicite de continuation (CPS) pour toute programmation
<em>avanc&eacute;e</em> (ce qui n'est pas sans rappeler &agrave;
TeX -- au fait quelqu'un a-t-il d&eacute;j&agrave; essay&eacute;
d'utiliser TeX comme macro-processeur pour autre chose que de la
mise-en-page?). Toutefois, ce n'est pas pire que cpp qui ne permet
ni citation ni r&eacute;cursivit&eacute;.</p>
<p>La bonne version de m4 &agrave; r&eacute;cup&eacute;rer est GNU
m4 1.4 (ou ult&eacute;rieure si elle existe). C'est celle qui
contient le plus de fonctionnalit&eacute; et le moins de bogues ou
de limitations. m4 est con&ccedil;u pour &ecirc;tre
intrins&egrave;quement lent pour toute utilisation sauf la plus
simple; cela suffit sans aucun doute pour la plupart des programmes
en assembleur (vous n'allez quand m&ecirc;me pas &eacute;crire des
millions de lignes en assembleur, si?).</p>
<h3>Macro-traitement avec votre propre filtre</h3>
<p>Vous pouvez &eacute;crire votre propre programme d'expansion de
macro avec les outils courants comme perl, awk, sed, etc. C'est
assez rapide &agrave; faire et vous pouvez tout contr&ocirc;ler.
Mais bien toute puissance dans le macro-traitement doit se gagner
&agrave; la dure.</p>
<h3>M&eacute;ta-programmation</h3>
<p>Plut&ocirc;t que d'utiliser un filtre externe qui effectue
l'expansion des macros, une mani&egrave;re de r&eacute;aliser cela
est d'&eacute;crire des programmes qui &eacute;crivent d'autres
programmes, en partie ou en totalit&eacute;.</p>
<p>Par exemple, vous pourriez utiliser un programme
g&eacute;n&eacute;rant du code source</p>
<ul>
<li>pour cr&eacute;er des tables de sinus/cosinus (ou autre),</li>
<li>pour d&eacute;compiler un fichier binaire en source
annot&eacute; annot&eacute;,</li>
<li>pour compiler vos bitmaps en des routines d'affichage
rapides,</li>
<li>pour extraire de la documentation, du code d'initilisation ou
finalisation, des tables de descriptions, aussi bien que du code
normal depuis les m&ecirc;mes fichiers sources;</li>
<li>pour utiliser une technique sp&eacute;cifique de production de
code, produite avec un script perl/shell/scheme</li>
<li>pour propager des donn&eacute;es d&eacute;finies en une seule
fois dans de nombreux morceaux de code ou tables avec
r&eacute;f&eacute;rences crois&eacute;es.</li>
<li>etc.</li>
</ul>
<p>Pensez-y!</p>
<h3>Backends provenant de compilateur existants</h3>
<p>Des compilateurs comme SML/NJ, Objective CAML, MIT-Scheme, etc,
ont leur propre g&eacute;n&eacute;rateur de code assembleur, que
vous pouvez ou non utiliser, si vous souhaitez
g&eacute;n&eacute;rer du code semi-automatiquement depuis les
langages correspondants.</p>
<h3>Le New-Jersey Machine-Code Toolkit</h3>
<p>Il s'agit projet utilisant le langage de programmation Icon pour
b&acirc;tir une base de code de manipulation d'assembleur. Voir
<a href=
"http://www.cs.virginia.edu/~nr/toolkit/">http://www.cs.virginia.edu/~nr/toolkit/</a></p>
<h3>Tunes</h3>
<p>Le projet de syst&egrave;me d'exploitation OS d&eacute;veloppe
son propre assembleur comme &eacute;tant une extension du langage
Scheme. Il ne fonctionne pas encore totalement, de l'aide est
bienvenue.</p>
<p>L'assembleur manipule des arbres de syntaxes symboliques, de
telle mani&egrave;re qu'il puisse servir comme base d'un traducteur
de syntaxe assembleur, un d&eacute;sassembleur, l'assembleur d'un
compilateur, etc. Le fait qu'il utile un vrai langage de
programmation puissant comme Scheme le rend imbatable pour le
macro-traitement et pour la m&eacute;ta-programmation.</p>
<p><a href=
"http://www.eleves.ens.fr:8080/home/rideau/Tunes/">http://www.eleves.ens.fr:8080/home/rideau/Tunes/</a></p>
<h2><a name="s5">5. Conventions d'appel</a></h2>
<h2><a name="ss5.1">5.1 Linux</a></h2>
<h3>Edition de liens avec GCC</h3>
<p>C'est la solution la plus pratique. Consultez la documentation
de gcc et prenez exemple sur les sources du noyau Linux (fichiers
<code>.S</code> qui sont utilis&eacute;s avec gas, non pas
as86).</p>
<p>Les arguments 32 bits sont empil&eacute;s dans la pile vers le
bas dans l'ordre inverse de l'ordre syntaxique (c'est-&agrave;-dire
qu'on acc&egrave;de aux arguments ou les d&eacute;pile dans l'ordre
syntaxique), au-dessus de l'adresse de retour 32 bits.
<code>%ebp</code>, <code>%esi</code>, <code>%edi</code>,
<code>%ebx</code> doivent &ecirc;tre conserv&eacute;s par
l'appel&eacute;, les autres registres peuvent &ecirc;tre
d&eacute;truits; <code>%eax</code> doit contenir le
r&eacute;sultat, ou <code>%edx:%eax</code> pour des
r&eacute;sultats sur 64 bits.</p>
<p>Pile virgule flottante: je ne suis pas s&ucirc;r, mais je pense
que le r&eacute;sultat se trouve dans <code>st(0)</code>, la pile
&eacute;tant &agrave; la discr&eacute;tion de l'appel&eacute;.</p>
<p>Notez que GCC poss&egrave;de certaines options pour modifier les
conventions d'appel en r&eacute;servant certains registres, en
mettant les arguments dans des registres, en supposant que l'on ne
poss&egrave;de pas de FPU, etc. Consultez les pages .info
concernant le i386.</p>
<p>Il faut prendre garde &agrave; d&eacute;clarer l'attribut
<code>cdecl</code> pour une fonction qui suit la convention
standard GCC (je ne sais pas exactement ce que cela produit avec
des conventions modifi&eacute;es). Consultez la documentation GCC
dans la section: <code>C Extensions::Extended Asm::</code></p>
<h3>Probl&egrave;mes ELF et a.out</h3>
<p>Certains compilateurs C ajoutent un underscore avant tout
symbole, alors que d'autres ne le font pas.</p>
<p>En particulier, la version GCC a.out effectue ce genre d'ajouts,
alors que la version ELF ne le fait pas.</p>
<p>Si vous &ecirc;tes confront&eacute; &agrave; ce probl&egrave;me,
regardez comment des paquetages existants traitent le
probl&egrave;mes. Par exemple, r&eacute;cup&eacute;rer une ancienne
arborescence des sources de Linux, Elk, les qthreads ou
OCAML...</p>
<p>Vous pouvez &eacute;galement red&eacute;finir le renommage
implicite de C en assembleur en ajoutant les instructions
suivantes:</p>
<hr>
<pre>
        void truc asm("machin") (void);
</pre>
<hr>
pour s'assurer que la fonction C truc sera r&eacute;ellement
appel&eacute;e machin en assembleur.
<p>Remarquez que l'outil <code>objcopy</code>, du paquetage
<code>binutils</code>, devrait vous permettre de transformer vos
fichiers objets a.out en objets ELF et peut-&ecirc;tre inversement
dans certains cas. D'une mani&egrave;re plus
g&eacute;n&eacute;rale, il vous permet d'effectuer de nombreuses
conversions de formats de fichiers.</p>
<h3>Appels syst&egrave;mes directs</h3>
<p>Il n'est absolument pas recommand&eacute; d'effectuer de tels
appels par ce que leurs conventions peuvent changer de temps en
temps, ou d'un type de noyau &agrave; un autre (cf L4Linux), de
plus, ce n'est pas portable, difficile &agrave; &eacute;crire,
redondant avec l'effort entrepris par libc, et enfin, cela
emp&ecirc;che les corrections et les extensions effectu&eacute;es
&agrave; travers la libc, comme par exemple avec le programme
<code>zlibc</code> qui r&eacute;alise une d&eacute;compression
&agrave; la vol&eacute;e de fichiers compress&eacute;s avec gzip.
La mani&egrave;re standard et recommend&eacute;e d'effectuer des
appels syst&egrave;mes est et restera de passer par la libc.</p>
<p>Les objets partag&eacute;s devraient r&eacute;duire l'occupation
m&eacute;moire des programmes, et si vous souhaitez absolument
avoir de petits ex&eacute;cutables, utilisez <code>#!</code> avec
un interpr&eacute;teur qui contiendra tout ce que vous ne voulez
pas mettre dans vos binaires.</p>
<p>Maintenant, si pour certaines raisons, vous ne souhaitez pas
effectuer une &eacute;dition des liens avec la libc,
r&eacute;cup&eacute;rez-la et essayez de comprendre comment elle
fonctionne! Apr&egrave;s tout, vous pr&eacute;tendez bien la
remplacer non?</p>
<p>Vous pouvez aussi regarder comment <a href=
"ftp://ftp.forth.org/pub/Forth/Linux/linux-eforth-1.0c.tgz">eforth
1.0c</a> le fait.</p>
<p>Les sources de Linux sont fort utiles, en particulier le fichier
d'en-t&ecirc;te asm/unistd.h qui d&eacute;crit comment sont
effectu&eacute;s les appels syst&egrave;me...</p>
<p>Le principe g&eacute;n&eacute;ral est d'utiliser l'instruction
<code>int $0x80</code> avec le num&eacute;ro de l'appel
syst&egrave;me <code>__NR_</code>machin (regarder dans
<code>asm/unistd.h</code>) dans <code>%eax</code>, et les
param&egrave;tres (jusqu'&agrave; cinq) dans <code>%ebx</code>,
<code>%ecx</code>, <code>%edx</code>, <code>%esi</code>,
<code>%edi</code>. Le r&eacute;sultat est renvoy&eacute; dans
<code>%eax</code> avec un r&eacute;sultat n&eacute;gatif
&eacute;tant l'erreur dont l'oppos&eacute; est
tranf&eacute;r&eacute; par la libc dans errno. La pile utilisateur
n'est pas modific&eacute;e donc n'avez pas besoin d'en avoir une
correcte lors de l'appel.</p>
<h3>Entr&eacute;es/sorties sous Linux</h3>
<p>Si vous souhaitez effectuer des entr&eacute;es/sorties
directement sous Linux, soit il s'agit de quelque chose de
tr&egrave;s simple qui n'a pas besoin de sp&eacute;cificit&eacute;s
du syst&egrave;me et dans ce cas l&agrave;, consultez le mini-HOWTO
<code>IO-Port-Programming</code>, ou alors vous devez cr&eacute;er
un nouveau gestionnaire de p&eacute;riph&eacute;rique et vous
devriez alors lire quelques documents sur les m&eacute;andres du
noyau, le d&eacute;veloppement de gestionnaires de
p&eacute;riph&eacute;riques, les modules du noyau, etc. Vous
trouverez d'excellents HOWTO ou autres documents du projet LDP.</p>
<p>Plus particuli&egrave;rement, si vous souhaitez r&eacute;aliser
des programmes graphiques, rejoignez le projet GGI: <a href=
"http://synergy.caltech.edu/~ggi/">http://synergy.caltech.edu/~ggi/</a>
<a href=
"http://sunserver1.rz.uni-duesseldorf.de/~becka/doc/scrdrv.html">http://sunserver1.rz.uni-duesseldorf.de/~becka/doc/scrdrv.html</a></p>
<p>Dans tous les cas, vous devriez plut&ocirc;t utiliser
l'assembleur en ligne de GCC avec les macros provenant des fichiers
linux/asm/*.h que d'&eacute;crire des sources en assembleur
pur.</p>
<h3>Acc&eacute;der aux gestionnaires 16 bits avec Linux/i386</h3>
<p>De telles choses sont th&eacute;oriquement possibles (preuve:
voir comment DOSEMU permet &agrave; des programmes d'acc&eacute;der
au port s&eacute;rie), et j'ai entendu des rumeurs que certaines
personnes le font (avec le gestionnaire PCI? Acc&egrave;s aux
cartes VESA? PnP ISA? Je ne sais pas). Si vous avez de plus amples
pr&eacute;cisions &agrave; ce sujet, soyez les bienvenus. Le bon
endroit &agrave; regarder est les sources du noyau, les sources de
DOSEMU (et des autres programmes se trouvant dans <a href=
"ftp://tsx-11.mit.edu/pub/linux/ALPHA/dosemu/">le r&eacute;pertoire
DOSEMU</a>), ainsi que les sources d'autres programmes bas niveaux
(peut-&ecirc;tre GGI s'il g&egrave;re les cartes VESA).</p>
<p>En fait, vous devez utiliser soit le mode prot&eacute;g&eacute;
16 bits, soit le mode vm86.</p>
<p>Le premier est plus simple &agrave; configurer mais il ne
fonctionne qu'avec du code ayant un comportement propre qui
n'effectue pas d'arithm&eacute;tique de segments ou d'adressage
absolu de segment (en particulier pour l'adressage du segment 0),
&agrave; moins que par chance tous les segments utilis&eacute;s
peuvent &ecirc;tre configur&eacute; &agrave; l'avance dans le
LDT.</p>
<p>La seconde possiblit&eacute; permet d'&ecirc;tre plus
"compatibles" avec les environnements 16 bits mais il
n&eacute;cessite une gestion bien plus compliqu&eacute;e.</p>
<p>Dans les deux cas, avant de sauter sur le code 16 bits, vous
devez:</p>
<ul>
<li>mmapper toute adresse absolue utilis&eacute;e dans le code 16
bits (comme la ROM, les tampons vid&eacute;o, les adresses DMA et
les entr&eacute;es/sorties passant des zones de m&eacute;moires
mapp&eacute;es) &agrave; partir de /dev/mem dans votre espace
d'adressage de votre processus.</li>
<li>configurer le LDT et/ou le moniteur en mode vm86.</li>
<li>demander au noyau les droits d'acc&egrave;s n&eacute;cessaires
pour les entr&eacute;es/sorties (voir plus haut).</li>
</ul>
<p>Encore une fois, lisez attentivement les codes sources
situ&eacute;s dans le r&eacute;pertoire de DOSEMU et consorts, en
particulier ces mini-&eacute;mulateurs permettant de faire tourner
des programmes ELKS et/ou des .COM assez simples sous
Linux/i386.</p>
<h2><a name="ss5.2">5.2 DOS</a></h2>
<p>La plupart des &eacute;mulateurs DOS sont livr&eacute;s avec
certaines interfaces d'acc&egrave;s aux services DOS. Lisez leur
documentation &agrave; ce sujet, mais bien souvent, ils ne font que
simuler <code>int $0x21</code> et ainsi de suite, donc c'est comme
si vous &eacute;tiez en mode r&eacute;el (je doute qu'ils aient de
possibilit&eacute;s de fonctionner avec des op&eacute;randes 32
bits: ils ne font que r&eacute;fl&eacute;chir l'interruption dans
le mode r&eacute;el ou dans le gestionnaire vm86).</p>
<p>Certaines documentations concernant DPMI (ou ses variantes
peuvent) &ecirc;tre trouv&eacute;es sur <a href=
"ftp://x2ftp.oulu.fi/pub/msdos/programming/">ftp://x2ftp.oulu.fi/pub/msdos/programming/</a></p>
<p>DJGPP est livr&eacute; avec son propre sous-ensemble,
d&eacute;riv&eacute;, ou remplacement (limit&eacute;) de la
glibc.</p>
<p>Il est possible d'effectuer une compilation crois&eacute;e de
Linux vers DOS. Consultez le r&eacute;pertoire devel/msdos/ de
votre miroir FTP de sunsite.unc.edu. Voir &eacute;galement le
dos-extender MOSS du projet Flux d'utah.</p>
<p>D'autres documentations et FAQ sont plus consacr&eacute;s
&agrave; DOS. Nous d&eacute;conseillons le d&eacute;veloppement
sous DOS.</p>
<h2><a name="ss5.3">5.3 Windauberies...</a></h2>
<p>Heu, ce document ne traite que de libre logiciel.
T&eacute;l&eacute;phonez-moi lorsque Windaube le deviendra ou du
moins ses outils de d&eacute;veloppement!</p>
<p>En fait, apr&egrave;s tout, cela existe: <a href=
"http://www.cygnus.com">Cygnus Solutions</a> a
d&eacute;velopp&eacute; la biblioth&egrave;que cygwin32.dll pour
que les programmes GNU puissent fonctionner sur les machines
MicroMerdiques. Donc, vous pouvez utiliser GCC, GAS et tous les
outils GNU ainsi que bon nombre d'applications Unix. Consultez leur
site Web. Je (Far&eacute;) ne souhaite pas m'&eacute;tendre sur la
programmation sous Windaube, mais je suis s&ucirc;r que vous
trouverez tout un tas d'informations partout...</p>
<h2><a name="ss5.4">5.4 Votre propre syst&egrave;me
d'exploitation</a></h2>
<p>Le contr&ocirc;le sur le syst&egrave;me &eacute;tant ce qui
attire de nombreux programmeurs vers l'assembleur, une
pr&eacute;misse ou un corollaire naturel de son utilisation est la
volont&eacute; de d&eacute;velopper son propre syst&egrave;me
d'exploitation. Remarquons tout d'abord que tout syst&egrave;me
permettant son auto-d&eacute;veloppement pourrait &ecirc;tre
qualifi&eacute; de syst&egrave;me d'exploitation, combien
m&ecirc;me tournerait-il au-dessus d'un autre syst&egrave;me sur
lequel il se d&eacute;chargerait de la gestion du multit&acirc;che
(Linux sur Mach) ou des entr&eacute;es/sorties (OpenGenera sur
Digital Unix), etc. Donc, pour simplifier le d&eacute;bogage, vous
pouvez souhaiter d&eacute;velopper votre syst&egrave;me
d'exploitation comme &eacute;tant un processus fonctionnant sous
Linux (au prix d'un certain ralentissement), puis, utiliser le
<a href="http://ww.cs.utah.edu/projects/flux/">Flux OS kit</a> (qui
permet l'utilisation des drivers Linux et BSD dans votre propre
syst&egrave;me d'exploitation) pour le rendre ind&eacute;pendant.
Lorsque votre syst&egrave;me est stable, il est toujours temps
d'&eacute;crire vos propres gestionnaires de mat&eacute;riels si
c'est vraiment votre passion.</p>
<p>Ce HowTo ne couvrira pas des sujets comme le code de chargement
du syst&egrave;me, le passage en mode 32 bits, la gestion des
interruptions, les bases concernant les horreurs des processeurs
Intel (mode prot&eacute;g&eacute;, V86/R86), la d&eacute;finition
de votre format d'objets ou de vos conventions d'appel. L'endroit
o&ugrave; vous pourrez trouver le plus d'informations concernant
tous ces sujets est le code source de syst&egrave;me
d&eacute;j&agrave; existants.</p>
<p>Un grand nombre de pointeurs se trouvent dans la page: <a href=
"http://www.eleves.ens.fr:8080/home/rideau/Tunes/Review/OSes.html">http://www.eleves.ens.fr:8080/home/rideau/Tunes/Review/OSes.html</a></p>
<h2><a name="s6">6. A faire et pointeurs</a></h2>
<ul>
<li>compl&eacute;ter les sections incompl&egrave;tes;</li>
<li>ajouter des pointeurs sur des programmes et des
documentations;</li>
<li>ajouter des exemples de tous les jours pour illustrer la
syntaxe, la puissance et les limitation de chacune des solutions
propos&eacute;es;</li>
<li>demander aux gens de me donner un coup de main;</li>
<li>trouver quelqu'un qui a assez de temps pour prendre en charge
la maintenance de ce HOWTO;</li>
<li>peut-&ecirc;tre dire quelques mots sur l'assembleur d'autres
plates-formes?</li>
<li>Quelques pointeurs (en plus de ceux qui se trouvent dans ce
document)
<ul>
<li><a href="http://www.intel.com/design/pentium/manuals/">pages de
manuel pour pentium</a></li>
<li><a href="http://www.eng.ufl.edu/ftp">hornet.eng.ufl.edu pour
les codages assembleurs</a></li>
<li><a href=
"ftp://ftp.luth.se/pub/msdos/demos/code/">ftp.luth.se</a></li>
<li><a href="ftp://zfja-gate.fuw.edu.pl/cpu/protect.mod">PM
FAQ</a></li>
<li><a href="http://www.fys.ruu.nl/~faber/Amain.html">Page
Assembleur 80x86</a></li>
<li><a href=
"http://www.cit.ac.nz/smac/csware.htm">Courseware</a></li>
<li><a href=
"http://www.ee.ucl.ac.uk/~phart/gameprog.html">programmation de
jeux</a></li>
<li><a href="http://bewoner.dma.be/JanW">experiences de
programmation sous Linux exclusivement en assembleur</a></li>
</ul>
</li>
<li>Et bien sur, utilisez vos outils habituels de recherche sur
Internet pour trouver les informations. Merci de m'envoyer tout ce
que vous trouvez d'interessant.</li>
</ul>
<p>Signature de l'auteur:</p>
<pre>
--    ,                                         ,           _ v    ~  ^  --
--
-- Fare -- rideau@clipper.ens.fr -- Francois-Rene Rideau -- +)ang-Vu Ban --
--                                      '                   / .          --
Join the TUNES project for a computing system based on computing freedom!
                 TUNES is a Useful, Not Expedient System
WWW page at URL: http://www.eleves.ens.fr:8080/home/rideau/Tunes/
</pre>
</body>
</html>
doc-linux-fr-html 2013.01-2 / usr / share / doc / HOWTO / fr-html / Assembly-HOWTO.html
