Discussion :

[corentin59]

Bonjour,

voici un bout de code (simplifié) issu de mon projet :

Code :

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

1
2
3
static double tab1[100];
static double tab2[50];
static double tab3[100];

En fait, la taille de "tab2" est insuffisante, il devrait contenir 100 éléments. Un peu plus loin dans mon code, je remplis les 100 éléments de "tab2". Comme il est mal alloué, j'écrase quelquepart des infos dans la mémoire. Comme tab2 est "static" et est entourée de variables "static", je n'ai pas de "segmentation fault" à l'execution, par contre, je ne connais pas la variable qui voit son contenu écrasé. Après recherche, je me rend compte que la variable écrasée n'est pas la même en fonction de la machine sur laquelle je compile. Ma question est donc : existe-il un flag de compilation qui me permet de fixer l'organisation dans la mémoire des variables (allouées en static) ?

Car mon probleme c'est que, en fonction de la variable qui est écrasée, un bug comme celui decrit ci-dessus est plus ou moins grave. Or quand on me signal un symptome, observé sur une machine et conséquence d'un bug, de mon côté, j'ai beau avoir le même bug, je n'observe pas le même symptôme.

Merci de vos lumières

[ram-0000]

A mon avis, corriger le bug sera moins prise de tête que de faire l'inventaire des comportements possibles en cas d'exécution du bug.

En plus tu sembles connaitre la cause du bug (tableau trop petit) donc soit tu agrandis la variable soit tu corriges la fonction pour ne pas qu'elle sorte des limites de la variable.

[corentin59]

biensûr que j'ai corrigé le bug. La question n'est pas là. Je travaille sur un très gros projet qui peut être compilé et executé sur plusieurs machines différentes. J'ai des utilisateurs qui me remonte des bugs que je n'ai pas sur ma machine. Etant donné le genre de bug exposé avant, j'aimerais que le script de compilation donne exactement la même chose, quelle que soit la machine (attention, quand je dis "machines différentes", ce n'est pas non plus "radicalement différentes" : ce sont des machines Linux, 64 bits)

Merci

[diogene]

... Car mon probleme c'est que, en fonction de la variable qui est écrasée, un bug comme celui decrit ci-dessus est plus ou moins grave. ...

Non, c'est toujours très grave ! On doit considérer que le programme est irrémédiablement détruit même sans symptomes apparents.

[corentin59]

Eh, si je pose la question, c'est bien que je veux corriger le bug !

Ma phrase était peut-être malheureuse, je voulais dire que "la conséquence du bug est plus ou moins visible" d'autant plus que cette conséquence dépend de la machine, d'où ma question ...

[LittleWhite]

Bonjour,

Si tu veux qu'un bug soit très visible, tu peux utiliser les assertions ( je sais plus si ça existe qu'en C++ , donc vous pouvez tirer si j'ai dit une connerie ).
Enfin tout un système qui permet de prévenir des cas de bugs avant que le programme ne plante ( mémoire alloué ? ... structure pour faire un tableau un peu plus poussé ... ( soit liste chainée like ) )
Tu peux aussi préparé des séries de tests ... ( enfin si c'est possible )

Enfin je propose, par ce que je suis pas sur de tout saisir ... :s

[corentin59]

En fait, indépendamment du bug décrit, j'aurais voulu savoir s'il existe un moyen (par exemple des flags de compilation à mettre ou à ne pas mettre) pour être sûr que la compilation se fasse exactement de la même manière, quelle que soit la machine sur laquelle on compile ?
Merci

[Jean-Marc.Bourguet]

En fait, indépendamment du bug décrit, j'aurais voulu savoir s'il existe un moyen (par exemple des flags de compilation à mettre ou à ne pas mettre) pour être sûr que la compilation se fasse exactement de la même manière, quelle que soit la machine sur laquelle on compile ?

Si je comprends bien, tu voudrais des flags qui forcent les comportements definis par l'implementation, les comportements non specifies et les comportements indefinis a se comporter de la meme maniere sur toutes les implementations. Non, il n'y en a pas.

[corentin59]

Si je comprends bien, tu voudrais des flags qui forcent les comportements definis par l'implementation, les comportements non specifies et les comportements indefinis a se comporter de la meme maniere sur toutes les implementations. Non, il n'y en a pas.

Décidement, c'est dûr de se faire comprendre !

Si je ne me trompe pas, l'emplacement mémoire des variables "static" est géré lors de la compilation, puisqu'elles font partie intégrante de la fonction. Est-il alors possible que cette gestion soit indépendante de la machine ? Dit d'une autre manière, est-il possible que l'ordre dans lequel sont placées les variables "static" en mémoire soit le même d'une machine à l'autre ?

[diogene]

Je ne vois pas de solution mis à part de regrouper tes données dans une même structure (et avoir les mêmes paramètres d'alignement sur les différentes machines) mais ça va amener à modifier lourdement le code.

[Jean-Marc.Bourguet]

Si je ne me trompe pas, l'emplacement mémoire des variables "static" est géré lors de la compilation, puisqu'elles font partie intégrante de la fonction.

Ca fait partie des choses qui sont non specifiees.

Est-il alors possible que cette gestion soit indépendante de la machine ? Dit d'une autre manière, est-il possible que l'ordre dans lequel sont placées les variables "static" en mémoire soit le même d'une machine à l'autre ?

Non. Et j'ai repondu par avance non aux questions similaires avec les quelles tu pourrais revenir chaque fois que tu as un comportement specifie par l'implementation, non specifie ou indefini qui gene ton debugging.

Il est possible que certaines implementations permettent de controler certaines choses (gcc a un flag pour choisir entre des char signes ou pas par exemple, les editeurs de liens ont souvent des systemes de map permettant de controler precisement l'emplacement de certaines choses pour donner un autre exemple plus proche de ta demande), mais dans le contexte que tu donnais, la complication de la mise en oeuvre depasse largement l'utilite.

[daniel06600]

Pour être sûr que les variables soient toujours dans le même ordre et ce quelque soit la machine qui compile, il faut que tu crée une union entre elles. Moi je ferai un tableau de 250 avec une union sur tab1/2/3. Comme ceci tes données seront placées à coup sûr dans le même ordre. J'ai déjà utilisé cette technique pour tester un éventuel débordement de data dans les tableaux avec quelque chose du type;
union datazone
tab1[size]
tst1[1]
tab2[size]
tst2[1]
tab3[size]
tst3[1]
Quelque part dans le programme je viens lire périodiquement le contenu des tst1/2/3 si leur contenu est altéré alors je déroute le soft vers un traitement d'erreur
J'epère que mon idée peut t'être utile, bonne journée

[diogene]

daniel06600 :

il faut que tu crée une union entre elles

Pas une union, mais une structure (comme signalé plus haut). Sinon, les variables partagent le même espace mémoire et ne sont plus indépendantes

[daniel06600]

Hé bien je suis désolé d'insister mais je confirme que c'est bien avec une union

[Mac LAK]

Hé bien je suis désolé d'insister mais je confirme que c'est bien avec une union

Avec une union, tes variables sont au même endroit. C'est bien une structure qu'il faut.

Exemple :

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
#include <stdio.h>
 
typedef union {
  int a ;
  int b ;
} test_union ;
 
typedef struct {
  int a ;
  int b ;
} test_struct ;
 
int main(int argc, char* argv[]) {
 
	test_union tu ;
	test_struct ts ;
 
	printf("Sizeof int\t\t\t: %d bytes\n",sizeof(int));
	printf("Sizeof union\t\t\t: %d bytes\n",sizeof(test_union));
	printf("Sizeof struct\t\t\t: %d bytes\n",sizeof(test_struct));
	printf("Adress of union\t\t\t: 0x%08x\n",&(tu));
	printf("Adress of 1st union field\t: 0x%08x (offset from union : %d)\n",&(tu.a),((char*)&(tu.a))-((char*)&(tu)));
	printf("Adress of 2nd union field\t: 0x%08x (offset from union : %d)\n",&(tu.b),((char*)&(tu.b))-((char*)&(tu)));
	printf("Adress of struct\t\t: 0x%08x\n",&(ts));
	printf("Adress of 1st struct field\t: 0x%08x (offset from struct : %d)\n",&(ts.a),((char*)&(ts.a))-((char*)&(ts)));
	printf("Adress of 2nd struct field\t: 0x%08x (offset from struct : %d)\n",&(ts.b),((char*)&(ts.b))-((char*)&(ts)));
	printf("\n\n");
	printf("Set 0 into all union / struct fields...\n");
	tu.a = 0 ;
	tu.b = 0 ;
	ts.a = 0 ;
	ts.b = 0 ;
	printf("\tUnion values\t: a=%d\tb=%d\n",tu.a,tu.b);
	printf("\tStruct values\t: a=%d\tb=%d\n",ts.a,ts.b);
	tu.a = 10 ;
	printf("Set 10 into union field a...\n");
	ts.a = 20 ;
	printf("Set 20 into struct field a...\n");
	printf("\tUnion values\t: a=%d\tb=%d\n",tu.a,tu.b);
	printf("\tStruct values\t: a=%d\tb=%d\n",ts.a,ts.b);
	tu.b = 30 ;
	printf("Set 30 into union field b...\n");
	ts.b = 40 ;
	printf("Set 40 into struct field b...\n");
	printf("\tUnion values\t: a=%d\tb=%d\n",tu.a,tu.b);
	printf("\tStruct values\t: a=%d\tb=%d\n",ts.a,ts.b);
 
	return 0;
}

Et le résultat :

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
Sizeof int                      : 4 bytes
Sizeof union                    : 4 bytes
Sizeof struct                   : 8 bytes
Adress of union                 : 0x0012ff60
Adress of 1st union field       : 0x0012ff60 (offset from union : 0)
Adress of 2nd union field       : 0x0012ff60 (offset from union : 0)
Adress of struct                : 0x0012ff50
Adress of 1st struct field      : 0x0012ff50 (offset from struct : 0)
Adress of 2nd struct field      : 0x0012ff54 (offset from struct : 4)
 
 
Set 0 into all union / struct fields...
        Union values    : a=0   b=0
        Struct values   : a=0   b=0
Set 10 into union field a...
Set 20 into struct field a...
        Union values    : a=10  b=10
        Struct values   : a=20  b=0
Set 30 into union field b...
Set 40 into struct field b...
        Union values    : a=30  b=30
        Struct values   : a=20  b=40

Sans appel : les champs de l'union sont tous au même endroit, et l'union ne fait pas 8 octets de longueur (la taille de deux ints, donc).

De plus, le test en deuxième partie de programme prouve bien que les valeurs de l'union s'écrasent mutuellement (ce qui était évident vu qu'elles sont à la même adresse), tandis que ça n'arrive pas avec la structure (évident là aussi vu que les adresses sont différentes).

Quand tu insistes, c'est mieux d'avoir raison, quand même...

[Emmanuel Delahaye]

Hé bien je suis désolé d'insister mais je confirme que c'est bien avec une union

Non.