Bonjour,

Je suis debutant et je fait quelques essais de compilation pour comprendre le fonctionnement.
J'ai un petit programme de test dont voici le source:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void toto();
 
main()
{
   toto();
   while(1) {}
   return( 0 );
}
 
void toto()
{
   asm {
      nop
      nop
      nop
   }
}
Rien de bien special, à noter que je compile sans utiliser de librairies.

Je compile avec Turbo C++ Version 1.01 et Turbo Link Version 3.01:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
TCC -c -ml -1 TEST.C
TLINK /n /x TEST
Puis de désassemble avec ndisasm j'obtiens:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
00000200  55                push bp
00000201  8BEC              mov bp,sp
00000203  0E                push cs
00000204  E80900            call 0x210
00000207  90                nop
00000208  EBFE              jmp short 0x208
0000020A  33C0              xor ax,ax
0000020C  EB00              jmp short 0x20e
0000020E  5D                pop bp
0000020F  CB                retf
00000210  55                push bp
00000211  8BEC              mov bp,sp
00000213  90                nop
00000214  90                nop
00000215  90                nop
00000216  5D                pop bp
00000217  CB                retf
Je commence en 200h, avant c'est l'entete DOS
On a bien l'appel a ma fonction toto : call 0x210, qui fait bien les 3 NOP, ensuite le while infini est traduit
en jmp short 0x208.

Jusque la je comprend, quoique je ne sais pas pourquoi le compilateur me rajoute un nop en 207h...

Quand je lance TCC seul, j'ai, en autre, dans les options:

-1 80186/286 Instructions -2 80286 Protected Mode Inst.

Si je compile par

Code : Sélectionner tout - Visualiser dans une fenêtre à part
TCC -c -2 TEST.C
J'obtient la meme chose en sortie, pourtant la je compile en 32 bits, je pense du code pour le mode protégé ?
le call 0x210 c'est pourtant du mode reel, un appel d'une fonction avec CS:0210h ?
En mode protégé on devrait appeler la fonctione avec une adresse sur 32 bits ? non ?

J'ai donc telecharger BCC 5.5 pour voir la difference, je recompile avec:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
BCC32 -c TEST.C
ILINK32 TEST
Puis de desassemble avec

ndisasm -u test.exe > test.asm

et la j'obtiens n'importe quoi:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
00000200  50                push eax
00000201  45                inc ebp
00000202  0000              add [eax],al
00000204  4C                dec esp
00000205  0103              add [ebx],eax
00000207  00FA              add dl,bh
00000209  8A0447            mov al,[edi+eax*2]
0000020C  0000              add [eax],al
0000020E  0000              add [eax],al
00000210  0000              add [eax],al
00000212  0000              add [eax],al
00000214  E000              loopne 0x216
00000216  0E                push cs
00000217  030B              add ecx,[ebx]
00000219  010500000000      add [0x0],eax
D'ou mon ultime question:

Actuellement je developpe un petit boot disk qui fonctionne bien en mode reel.
J'ai un programme en assembleur pour le secteur de boot, qui enchaine sur un programme en C.
Je compile le tout en 16 bits car je reste en mode reel.

Je compte tester un passage en mode protege, pour se faire j'initialise la GDT dans mon programme en C, puis
je vais pointer sur un programme en C mais en 32 bits que j'aurais préalablement chargé dans
une partie de la memoire.

Si la compilation en mode 16 bits ne me pose pas de probleme, comment compiler un programme en mode 32 bits ?
Je pense que ce qui change c'est l'utilisation des registre etendu (EAX...) bien qu'ils soit possible de les utiliser
en mode reel, mais surtout l'adressage des fonctions, qui je pense ne se fait plus avec CSC mais directement
à partir d'une adresse sur 32bits.

Quel compilateur et editeur de liens puis-je utiliser pour me generer du code 32 bits ?
Ou trouver un debugger qui gere le 32 bits ?

Merci de vos reponses !