Bug d'overflow déroutant ! [en partie résolu]

**le_duche** · 09/04/2008, 15h34

Bonjour à tous !

Précisions nécessaires:
Config:
Mac Os X 10.5.2
Environnement de compilation:
Xcode Version 3.0
Component version
Xcode IDE 921.0
Xcode core 921.0
ToolSupport 893.0

C'est bien la première fois que je suis confronté à ce bug ! Petite histoire:
Suite à un bug que je ne comprenais vraiment pas, j'ai simplifié mon code de plus en plus tout en maintenant le bug:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
using namespace std;
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1100000000;
	while(compteur < 1100000000)
	{
		cout << compteur << endl;
		compteur += 10000;
	}
	return 0;
}

Ce code ne s'arrête pas et l'affichage du compteur montre bien que le programme rentre dans la boucle au delà de la borne 1100000000... puis retombe dans les négatif et reprend sa montée... et ainsi de suite.

Petit chipotage pour obtenir ceci:

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
 
#include <iostream>
using namespace std;
 
bool bug(int truc)
{
	return (truc > 1100000000);
}
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1100000000;
	while(compteur < 1100000000)
	{
		cout << compteur << endl;
		if(bug(compteur))
		{
			cout << " BUG ! " << endl;
			int a;
			cin >> a;
		}
		compteur += 10000;
	}
	return 0;
}

Ce programme là s'arrête bien pour me demander la valeur de a.
Cependant celui-ci ne le fait plus et cycle sans entrer dans le if:

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
 
#include <iostream>
using namespace std;
 
bool bug(int truc)
{
	return (truc > 1100000000);
}
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1100000000;
	while(compteur < 1100000000)
	{
		cout << compteur << endl;
		if(bug(compteur))
		{
			cout << " BUG ! " << endl;
			int a;
			cin >> a;
			break;
		}
		compteur += 10000;
	}
	return 0;
}

Contre toute attente, je retire le cout:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <iostream>
using namespace std;
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1100000000;
	while(compteur < 1100000000)
	{
		compteur += 10000;
	}
	return 0;
}

Et cette fois le programme s'arrête ! Ce qui ne devrait pas arriver si le bug se poursuivait.

D'autre part, les codes suivants, avec les bornes modifiées, fonctionnent parfaitement:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
using namespace std;
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = 0;
	while(compteur < 1100000000)
	{
		cout << compteur << endl;
		compteur += 10000;
	}
	return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
using namespace std;
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1100000000;
	while(compteur < 0)
	{
		cout << compteur << endl;
		compteur += 10000;
	}
	return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
#include <iostream>
using namespace std;
 
int main(int sys_nbr_args,char** sys_args)
{
	int compteur = -1000000000;
	while(compteur < 1000000000)
	{
		cout << compteur << endl;
		compteur += 10000;
	}
	return 0;
}

Il semblerait donc que parcourir plus de 31 bits de valeurs pour une boucle pose des problèmes...

Après un désassemblage (c'est pas moi qui ai regardé, je ne connais pas l'asm), il semblerait que la valeur de la borne soit modifiée.
Après un gros chipotage (apparition du bug vers 11h00 tout de même

), j'ai choisi l'option "Project > Set Active Build Configuration > Débug" qui, si j'ai bien compris, interdit l'optimisation du code lors de la compilation.
Avec cette option tout marche comme sur des roulettes.

Il semblerait donc que ce soit le compilateur qui optimise comme une andouille, créant des effets de bords sur des constantes et des entrées de boucle...

Cependant, c'est loin d'être une solution, car j'ai beau avoir du code qui marche, l'exécutable engendré sera plus lourd et plus lent sans optimisation.

Quelqu'un a-t-il déjà rencontré ce problème ?
Avez-vous une solution à me proposer ?
Je ne sais pas où ni s'il est possible de paramétrer la latitude laissée au compilateur dans l'optimisation...