This file is indexed.

/usr/share/doc/HOWTO/fr-html/Assembly-HOWTO.html is in doc-linux-fr-html 2013.01-3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

   1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133
 134
 135
 136
 137
 138
 139
 140
 141
 142
 143
 144
 145
 146
 147
 148
 149
 150
 151
 152
 153
 154
 155
 156
 157
 158
 159
 160
 161
 162
 163
 164
 165
 166
 167
 168
 169
 170
 171
 172
 173
 174
 175
 176
 177
 178
 179
 180
 181
 182
 183
 184
 185
 186
 187
 188
 189
 190
 191
 192
 193
 194
 195
 196
 197
 198
 199
 200
 201
 202
 203
 204
 205
 206
 207
 208
 209
 210
 211
 212
 213
 214
 215
 216
 217
 218
 219
 220
 221
 222
 223
 224
 225
 226
 227
 228
 229
 230
 231
 232
 233
 234
 235
 236
 237
 238
 239
 240
 241
 242
 243
 244
 245
 246
 247
 248
 249
 250
 251
 252
 253
 254
 255
 256
 257
 258
 259
 260
 261
 262
 263
 264
 265
 266
 267
 268
 269
 270
 271
 272
 273
 274
 275
 276
 277
 278
 279
 280
 281
 282
 283
 284
 285
 286
 287
 288
 289
 290
 291
 292
 293
 294
 295
 296
 297
 298
 299
 300
 301
 302
 303
 304
 305
 306
 307
 308
 309
 310
 311
 312
 313
 314
 315
 316
 317
 318
 319
 320
 321
 322
 323
 324
 325
 326
 327
 328
 329
 330
 331
 332
 333
 334
 335
 336
 337
 338
 339
 340
 341
 342
 343
 344
 345
 346
 347
 348
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382
 383
 384
 385
 386
 387
 388
 389
 390
 391
 392
 393
 394
 395
 396
 397
 398
 399
 400
 401
 402
 403
 404
 405
 406
 407
 408
 409
 410
 411
 412
 413
 414
 415
 416
 417
 418
 419
 420
 421
 422
 423
 424
 425
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436
 437
 438
 439
 440
 441
 442
 443
 444
 445
 446
 447
 448
 449
 450
 451
 452
 453
 454
 455
 456
 457
 458
 459
 460
 461
 462
 463
 464
 465
 466
 467
 468
 469
 470
 471
 472
 473
 474
 475
 476
 477
 478
 479
 480
 481
 482
 483
 484
 485
 486
 487
 488
 489
 490
 491
 492
 493
 494
 495
 496
 497
 498
 499
 500
 501
 502
 503
 504
 505
 506
 507
 508
 509
 510
 511
 512
 513
 514
 515
 516
 517
 518
 519
 520
 521
 522
 523
 524
 525
 526
 527
 528
 529
 530
 531
 532
 533
 534
 535
 536
 537
 538
 539
 540
 541
 542
 543
 544
 545
 546
 547
 548
 549
 550
 551
 552
 553
 554
 555
 556
 557
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568
 569
 570
 571
 572
 573
 574
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585
 586
 587
 588
 589
 590
 591
 592
 593
 594
 595
 596
 597
 598
 599
 600
 601
 602
 603
 604
 605
 606
 607
 608
 609
 610
 611
 612
 613
 614
 615
 616
 617
 618
 619
 620
 621
 622
 623
 624
 625
 626
 627
 628
 629
 630
 631
 632
 633
 634
 635
 636
 637
 638
 639
 640
 641
 642
 643
 644
 645
 646
 647
 648
 649
 650
 651
 652
 653
 654
 655
 656
 657
 658
 659
 660
 661
 662
 663
 664
 665
 666
 667
 668
 669
 670
 671
 672
 673
 674
 675
 676
 677
 678
 679
 680
 681
 682
 683
 684
 685
 686
 687
 688
 689
 690
 691
 692
 693
 694
 695
 696
 697
 698
 699
 700
 701
 702
 703
 704
 705
 706
 707
 708
 709
 710
 711
 712
 713
 714
 715
 716
 717
 718
 719
 720
 721
 722
 723
 724
 725
 726
 727
 728
 729
 730
 731
 732
 733
 734
 735
 736
 737
 738
 739
 740
 741
 742
 743
 744
 745
 746
 747
 748
 749
 750
 751
 752
 753
 754
 755
 756
 757
 758
 759
 760
 761
 762
 763
 764
 765
 766
 767
 768
 769
 770
 771
 772
 773
 774
 775
 776
 777
 778
 779
 780
 781
 782
 783
 784
 785
 786
 787
 788
 789
 790
 791
 792
 793
 794
 795
 796
 797
 798
 799
 800
 801
 802
 803
 804
 805
 806
 807
 808
 809
 810
 811
 812
 813
 814
 815
 816
 817
 818
 819
 820
 821
 822
 823
 824
 825
 826
 827
 828
 829
 830
 831
 832
 833
 834
 835
 836
 837
 838
 839
 840
 841
 842
 843
 844
 845
 846
 847
 848
 849
 850
 851
 852
 853
 854
 855
 856
 857
 858
 859
 860
 861
 862
 863
 864
 865
 866
 867
 868
 869
 870
 871
 872
 873
 874
 875
 876
 877
 878
 879
 880
 881
 882
 883
 884
 885
 886
 887
 888
 889
 890
 891
 892
 893
 894
 895
 896
 897
 898
 899
 900
 901
 902
 903
 904
 905
 906
 907
 908
 909
 910
 911
 912
 913
 914
 915
 916
 917
 918
 919
 920
 921
 922
 923
 924
 925
 926
 927
 928
 929
 930
 931
 932
 933
 934
 935
 936
 937
 938
 939
 940
 941
 942
 943
 944
 945
 946
 947
 948
 949
 950
 951
 952
 953
 954
 955
 956
 957
 958
 959
 960
 961
 962
 963
 964
 965
 966
 967
 968
 969
 970
 971
 972
 973
 974
 975
 976
 977
 978
 979
 980
 981
 982
 983
 984
 985
 986
 987
 988
 989
 990
 991
 992
 993
 994
 995
 996
 997
 998
 999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content=
"HTML Tidy for Linux (vers 25 March 2009), see www.w3.org">
<meta name="GENERATOR" content="LinuxDoc-Tools 0.9.71">
<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>