Discussion :

[Mercenary Developer]

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 !

[Mercenary Developer]

Re-bonjour,

J'ai fait un essai avec TASM32, ca me donne la meme chose mais le code source doit etre different.

Pour resumer:

Code source mode reel:

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
18
19
20
21
22
23
24
25
26
27
Code Segment
	Assume CS:Code, DS:Data, SS:Pile
 
Main PROC
   XOR AX, AX
   XOR BX, BX
   CALL yoyo
boucle:
   JMP boucle
yoyo:
   NOP
   NOP
   NOP
   RET
Main ENDP
 
Code Ends
 
Data Segment
   DB 10 Dup(6)
Data Ends
 
Pile Segment stack
   DB 256 DUP(?)
Pile Ends
 
End Main

Compilation avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
TASM /m2 TOTO16
TLINK TOTO16

Resultat apres un NDISASM:

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  33C0              xor ax,ax
00000202  33DB              xor bx,bx
00000204  E80200            call 0x209
00000207  EBFE              jmp short 0x207
00000209  90                nop
0000020A  90                nop
0000020B  90                nop
0000020C  C3                ret
0000020D  0000              add [bx+si],al
0000020F  00060606          add [0x606],al
00000213  06                push es
00000214  06                push es
00000215  06                push es
00000216  06                push es
00000217  06                push es
00000218  06                push es
00000219  06                push es

Code source mode protege (32 bits):

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
18
19
20
21
22
.386
.model flat
 
.code
 
Main PROC
   XOR AX, AX
   XOR BX, BX
   CALL yoyo
boucle:
   JMP boucle
yoyo:
   NOP
   NOP
   NOP
   RET
Main ENDP
 
.data
   DB 10 Dup(6)
 
end Main

Compilation avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
TASM32 /m2 TOTO32
TLINK32 TOTO32

Resultat apres un NDISASM -u :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
00000600  6633C0            xor ax,ax
00000603  6633DB            xor bx,bx
00000606  E802000000        call 0x60d
0000060B  EBFE              jmp short 0x60b
0000060D  90                nop
0000060E  90                nop
0000060F  90                nop
00000610  C3                ret

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
00000801  06                push es
00000802  06                push es
00000803  06                push es
00000804  06                push es
00000805  06                push es
00000806  06                push es
00000807  06                push es
00000808  06                push es
00000809  06                push es

Deux remarques: En mode reel le code commence en 200h, apres l'entete DOS, en mode protege il commence en 600h, l'entete est donc differente ???

Ensuite les donnees viennent juste apres le code en mode reel, en mode protege on les retrouve en 800h.

Donc, quand je voulais essayer mon boot disk en mode reel pas de probleme, je copie secteur apres secteur le programme sur la disquette sans tenir compte de n'entete DOS. Mais en mode protege comment doit-je faire ? Je copie betement tout à partir de 600h et ensuite je recharge tout en memoire ?

Je cherche un compilateur C capable de me generer un fichier EXE dos en 32 bits, pouvez-vous m'indiquer un nom de compilateur ?

Cordialement.

[Mercenary Developer]

Re-re-bonjour.

Bon j'ai trouve un BCC32 pour compiler mon code C en 32bits, mais un probleme subsiste. Voici mon code C:

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
18
19
20
21
22
23
24
25
void toto();
 
unsigned int var = 0x1234;
 
main()
{
   toto();
   asm {
      nop
   }   
   var = 0x4567;
   asm {
      nop
   }   
   while(1) {}
}
 
void toto()
{
   asm {
      nop
      nop
      nop
   }
}

Si je le compile en 16 bits avec:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
TCC -c -ml TOTO.C
TLINK /n /x TOTO

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
18
19
00000200  55                push bp
00000201  8BEC              mov bp,sp
00000203  0E                push cs
00000204  E80D00            call 0x214
00000207  90                nop
00000208  90                nop
00000209  C7060C006745      mov word [0xc],0x4567
0000020F  90                nop
00000210  EBFE              jmp short 0x210
00000212  5D                pop bp
00000213  CB                retf
00000214  55                push bp
00000215  8BEC              mov bp,sp
00000217  90                nop
00000218  90                nop
00000219  90                nop
0000021A  5D                pop bp
0000021B  CB                retf
0000021C  3412              xor al,0x12

Rien de special, on va bien chercher les donnees en 0xc, soit le segment 0x0021 (=DS) et l'offset 0x000C.

Si je le compile en mode 32 bits par:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
BCC32 -c TOTO.C
TLINK32 TOTO

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
000005FF  00558B            add [ebp-0x75],dl
00000602  EC                in al,dx
00000603  E810000000        call 0x618
00000608  90                nop
00000609  C705002040006745  mov dword [0x402000],0x4567
         -0000
00000613  90                nop
00000614  EBFE              jmp short 0x614
00000616  5D                pop ebp
00000617  C3                ret
00000618  55                push ebp
00000619  8BEC              mov ebp,esp
0000061B  90                nop
0000061C  90                nop
0000061D  90                nop
0000061E  5D                pop ebp
0000061F  C3                ret

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

00000800  3412              xor al,0x12

A par un leger bug de ndisasm pour les lignes 5FF et 602, on obtiens quelque chose de correcte sauf:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
00000609  C705002040006745  mov dword [0x402000],0x4567
         -0000

D'ou a-t-il trouve cette adresse 0x402000 ? Mes données se trouve en 800h dans ce fichier. Donc au pire j'aurais du trouver 0x200h ( 800h - 600h de l'entete ) ?

Pouvez-vous m'expliquer d'ou vient le probleme ?

Cordialement.

[Mercenary Developer]

Bonjour,

Il s'agit d'une valeur par defaut, parametrable avec NASM, pour l'adresse des données en mode protege.

Enfin je pense d'apres mes recherches...