Discussion :

[r0d]

Bonjour à tous,

j'ai remarqué que la taille de l'exécutable de l'appli sur laquelle je travaille en ce moment varie d'une machine à l'autre. Je veux dire que selon sur quelle machine il est compilé, la taille de l'exécutable varie. Et la différence peut atteindre des proportions grotesques, par exemple 19Mo sur une machine, 1,6Mo sur une autre.

Première piste: environnement différents. Sur certaines machines, l'appli est compilée avec Code::Blocks, et sur d'autres, directement avec des makefile. Je me suis dis "on ne sait jamais" (notemment je me suis dit qu'il pourrait y avoir des différences sur les options de compilation), et j'ai effectué quelques comparaisons. Résultat: il peut y avoir une différence de la taille de le l'executable, mais elle est négligeable.

Deuxième piste: le compilo. Et là... surprise. Dans tous les cas, nous utilisons gcc, mais en effet, il y a plusieurs versions distinctes. Aprés quelques tests, j'ai il apparait que la version 4.1.2 de gcc créé du code 10 fois plus grand (en taille) que la version gcc 4.0.3.

Questions:
-> est-ce possible? Une telle différence me parait incroyable.
-> comment expliquer un telle différence?
-> peut-on configurer gcc pour limiter la taille de l'executable (je ne parle pas des options de compiliation)?
-> est-ce que quelqu'un s'est déjà penché sur le problème et aurait quelques remarques pertinentes sur le sujet?

[screetch]

sous linux, la STL est une lib dynamique. Sous windows, point de dynamisme vu qu'il n'y a pas de repertoire /lib ou equivalent. je suppute que gcc colle toute la stl et la lib C dans ton executable. si tu utilises des makefiles, passe un coup de strip -s sur l'executable derriere, sinon peut etre en explorant quelques options...

[screetch]

strip -s c'est pas du tout ca, mais man strip te diras plus.

http://www.hmug.org/man/1/strip.php

[r0d]

Mhh, bah justement je suis sous linux, ubuntu pour être précis.
Je ne trouve pas grand chose pour configurer gcc... je suis parti sur le wiki de gcc (gcc.gnu.org) mais c'est un peu le foutoir je trouve

[Médinoc]

Sous windows, point de dynamisme vu qu'il n'y a pas de repertoire /lib ou equivalent. je suppute que gcc colle toute la stl et la lib C dans ton executable.

Ahem!
MSVCPRT.DLL contient la version dynamique de la STL...

[screetch]

j'ai essayé chez moi avec ce que j'avais (c'est a dire g++ 4.1, 4.2, 4.3 et g++ cross-platform 4.1 pour windows)

voila les tailles des exe:

Code :

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

1
2
3
4
5
-rw-r--r-- 1 screetch screetch      92 Feb 28 07:47 main.cc
-rwxr-xr-x 1 screetch screetch   10783 Feb 28 07:50 main4.1
-rwxr-xr-x 1 screetch screetch 1015410 Feb 28 07:54 main4.1.exe
-rwxr-xr-x 1 screetch screetch   12248 Feb 28 07:54 main4.2
-rwxr-xr-x 1 screetch screetch   10823 Feb 28 07:50 main4.3

chez moi l'exe fait pour windows fait 1 meg alors que les autres font 10k (c'est un simple hello world)

en analysant le listing donné par objdump, on voit beaucoup de fonctions de la libc:
voila juste un extrait

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
0040b078 <_strcmp>:
  40b078:	ff 25 e8 b2 48 00    	jmp    *0x48b2e8
  40b07e:	90                   	nop    
  40b07f:	90                   	nop    
	...
 
0040b088 <_strcpy>:
  40b088:	ff 25 f0 b2 48 00    	jmp    *0x48b2f0
  40b08e:	90                   	nop    
  40b08f:	90                   	nop    
	...
 
0040b098 <_fopen>:
  40b098:	ff 25 94 b2 48 00    	jmp    *0x48b294
  40b09e:	90                   	nop    
  40b09f:	90                   	nop    
	...
 
0040b0a8 <__lseeki64>:
  40b0a8:	ff 25 74 b2 48 00    	jmp    *0x48b274
  40b0ae:	90                   	nop    
  40b0af:	90                   	nop

ce n'est qu'un wrapper mais il est present et prend enormement de place. De plus je n'ai rien demandé mais je meretrouve avec les fonctions win32 aussi :

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
28
29
30
31
32
33
34
0040b268 <_GetLastError@0>:
  40b268:	ff 25 d4 b1 48 00    	jmp    *0x48b1d4
  40b26e:	90                   	nop    
  40b26f:	90                   	nop    
	...
 
0040b278 <_TlsSetValue@8>:
  40b278:	ff 25 18 b2 48 00    	jmp    *0x48b218
  40b27e:	90                   	nop    
  40b27f:	90                   	nop    
	...
 
0040b288 <_TlsGetValue@4>:
  40b288:	ff 25 14 b2 48 00    	jmp    *0x48b214
  40b28e:	90                   	nop    
  40b28f:	90                   	nop    
	...
 
0040b298 <_SetLastError@4>:
  40b298:	ff 25 00 b2 48 00    	jmp    *0x48b200
  40b29e:	90                   	nop    
  40b29f:	90                   	nop    
	...
 
0040b2a8 <_InterlockedDecrement@4>:
  40b2a8:	ff 25 e4 b1 48 00    	jmp    *0x48b1e4
  40b2ae:	90                   	nop    
  40b2af:	90                   	nop    
	...
 
0040b2b8 <_ReleaseSemaphore@12>:
  40b2b8:	ff 25 fc b1 48 00    	jmp    *0x48b1fc
  40b2be:	90                   	nop    
  40b2bf:	90                   	nop

et enfin la stl qui elle n'a meme pas l'air d'etre wrappée et qui est integralement recopiée.

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
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
00412378 <__ZNKSt5ctypeIwE8do_widenEPKcS2_Pw>:
  412378:	55                   	push   %ebp
  412379:	89 e5                	mov    %esp,%ebp
  41237b:	56                   	push   %esi
  41237c:	53                   	push   %ebx
  41237d:	8b 55 0c             	mov    0xc(%ebp),%edx
  412380:	8b 5d 10             	mov    0x10(%ebp),%ebx
  412383:	8b 75 08             	mov    0x8(%ebp),%esi
  412386:	8b 4d 14             	mov    0x14(%ebp),%ecx
  412389:	39 da                	cmp    %ebx,%edx
  41238b:	73 17                	jae    4123a4 <__ZNKSt5ctypeIwE8do_widenEPKcS2_Pw+0x2c>
  41238d:	31 c0                	xor    %eax,%eax
  41238f:	8a 02                	mov    (%edx),%al
  412391:	42                   	inc    %edx
  412392:	66 8b 84 46 8e 00 00 	mov    0x8e(%esi,%eax,2),%ax
  412399:	00 
  41239a:	66 89 01             	mov    %ax,(%ecx)
  41239d:	83 c1 02             	add    $0x2,%ecx
  4123a0:	39 da                	cmp    %ebx,%edx
  4123a2:	75 e9                	jne    41238d <__ZNKSt5ctypeIwE8do_widenEPKcS2_Pw+0x15>
  4123a4:	89 d8                	mov    %ebx,%eax
  4123a6:	5b                   	pop    %ebx
  4123a7:	5e                   	pop    %esi
  4123a8:	5d                   	pop    %ebp
  4123a9:	c3                   	ret    
  4123aa:	90                   	nop    
  4123ab:	90                   	nop    
  4123ac:	90                   	nop    
  4123ad:	90                   	nop    
  4123ae:	90                   	nop    
  4123af:	90                   	nop    
  4123b0:	90                   	nop    
  4123b1:	90                   	nop    
  4123b2:	90                   	nop    
  4123b3:	90                   	nop    
  4123b4:	90                   	nop    
  4123b5:	90                   	nop    
  4123b6:	90                   	nop    
  4123b7:	90                   	nop    
 
004123b8 <__ZNKSt5ctypeIwE8do_widenEc>:
  4123b8:	55                   	push   %ebp
  4123b9:	31 d2                	xor    %edx,%edx
  4123bb:	89 e5                	mov    %esp,%ebp
  4123bd:	8a 55 0c             	mov    0xc(%ebp),%dl
  4123c0:	8b 45 08             	mov    0x8(%ebp),%eax
  4123c3:	5d                   	pop    %ebp
  4123c4:	66 8b 84 50 8e 00 00 	mov    0x8e(%eax,%edx,2),%ax
  4123cb:	00 
  4123cc:	25 ff ff 00 00       	and    $0xffff,%eax
  4123d1:	c3                   	ret    
  4123d2:	90                   	nop    
  4123d3:	90                   	nop    
  4123d4:	90                   	nop    
  4123d5:	90                   	nop    
  4123d6:	90                   	nop    
  4123d7:	90                   	nop

pour les exe linux, rien de tout cela : seules les fonctions necessaires ont été générées.



Je suis quand meme pas fou hein

par contre pour la taille des exe linux la je ne sais pas.

[Médinoc]

Vu que c'est configurable sous Visual, ça doit l'être aussi pour MinGW.

Quant à la STL, il est normal que beaucoup de templates soient recopiés. Seuls certains, connus à l'avance, peuvent être déjà compilés dans une bibliothèque (notamment basic_string<char>, basic_string<wchar_t>, les objets cin, cout, cerr, certains conteneurs comme vector<int>, les classes de base non-template des conteneurs, etc.). Et si cette bibliothèque est dynamique, tout ça peut être sorti de l'Exe.

Les appels à l'API Win32 (notamment des fonctions caractéristiques comme TlsGetValue()) montrent que la CRT a été recopiée dans l'Exe, donc que ton MinGW compile en statique. J'ignore quel est le réglage de MinGW pour fonctionner en dynamique...

[screetch]

il n'y a pas de template dans le code. c'est un simple hello world, ce que tu vois est le code tiré par iostream inclus en statique.

ensuite ce n'est pas MON mingw. c'est juste mingw.

enfin, je n'ai pas trouvé de libstdc++ dynamique dans la distribution de mingw que j'ai. cela peut changer d'une version a l'autre.

Sous linux il doit cependant etre possible de changer entre statique et dynamique, rod tu pourras essayer de lier avec les libs dynamiques (je ne sais pas comment changer cela...)