Generer du code 32 bits

Version imprimable

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:

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:

1 2 TCC -c -ml -1 TEST.C TLINK /n /x TEST
Puis de désassemble avec ndisasm j'obtiens:
Code:

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:

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:

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:

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 CS:PC 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 !

TASM32

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:

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:

1
2
TASM /m2 TOTO16
TLINK TOTO16

Resultat apres un NDISASM:

Code:

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:

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:

1
2
TASM32 /m2 TOTO32
TLINK32 TOTO32

Resultat apres un NDISASM -u :

Code:

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:

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.

J'avance...

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:

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:

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

J'obtiens:

Code:

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:

1
2
BCC32 -c TOTO.C
TLINK32 TOTO

J'obtiens:

Code:

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:

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:

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.

16/11/2007, 08h33
Mercenary Developer

Trouve

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...