Valgrind et fuite de mémoire

**Dasson** · 28/07/2009, 10h34

Bonjour

Je suis entrain de finaliser mon projet qui est un petit compilateur, et le problème que j'ai est que j'ai encore des blocs atteignables.

Le problème est que ces blocs en questions viennent de fichier générer par lex et yacc, donc je ne sais pas trop comment résoudre ce problème. J'ai déjà essayé de les supprimer puis de les re-générer mais rien n'y fait, le problème persiste.

Pourriez vous m'éclaircir sur ce point ?

Voici le log de valgrind :

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
==7766== 
==7766== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 8 from 1)
==7766== malloc/free: in use at exit: 16,458 bytes in 3 blocks.
==7766== malloc/free: 65 allocs, 62 frees, 18,828 bytes allocated.
==7766== For counts of detected errors, rerun with: -v
==7766== searching for pointers to 3 not-freed blocks.
==7766== checked 73,648 bytes.
==7766== 
==7766== 8 bytes in 1 blocks are still reachable in loss record 1 of 3
==7766==    at 0x4C278AE: malloc (vg_replace_malloc.c:207)
==7766==    by 0x403E24: yyalloc (lex.yy.c:2104)
==7766==    by 0x403950: yyensure_buffer_stack (lex.yy.c:1803)
==7766==    by 0x401F8B: yylex (lex.yy.c:778)
==7766==    by 0x406E4F: yyparse (y.tab.c:1465)
==7766==    by 0x408265: main (LSD09-BDP.y:220)
==7766== 
==7766== 
==7766== 64 bytes in 1 blocks are still reachable in loss record 2 of 3
==7766==    at 0x4C278AE: malloc (vg_replace_malloc.c:207)
==7766==    by 0x403E24: yyalloc (lex.yy.c:2104)
==7766==    by 0x4034B8: yy_create_buffer (lex.yy.c:1639)
==7766==    by 0x401FB2: yylex (lex.yy.c:779)
==7766==    by 0x406E4F: yyparse (y.tab.c:1465)
==7766==    by 0x408265: main (LSD09-BDP.y:220)
==7766== 
==7766== 
==7766== 16,386 bytes in 1 blocks are still reachable in loss record 3 of 3
==7766==    at 0x4C278AE: malloc (vg_replace_malloc.c:207)
==7766==    by 0x403E24: yyalloc (lex.yy.c:2104)
==7766==    by 0x4034EC: yy_create_buffer (lex.yy.c:1648)
==7766==    by 0x401FB2: yylex (lex.yy.c:779)
==7766==    by 0x406E4F: yyparse (y.tab.c:1465)
==7766==    by 0x408265: main (LSD09-BDP.y:220)
==7766== 
==7766== LEAK SUMMARY:
==7766==    definitely lost: 0 bytes in 0 blocks.
==7766==      possibly lost: 0 bytes in 0 blocks.
==7766==    still reachable: 16,458 bytes in 3 blocks.
==7766==         suppressed: 0 bytes in 0 blocks.

la ligne 220 du fichire LSD09-BDP.y fait un appel à yyparse();.

Merci bien

Dasson

**nicolas.sitbon** · 28/07/2009, 10h54

Le fait qu'il soit atteignable indique simplement que tu as toujours un pointeur sur cette mémoire, le tout est maintenant de la libérer. Soit tu le fais toi même, soit tu postes le code (compilable, pas un bout de code) si tu veux qu'on t'aide.
Cordialement.

**Dasson** · 28/07/2009, 11h01

Vous parlez d'un bout de programme que j'exécute avec mon compilateur ou du code de mon compilateur ?

**nicolas.sitbon** · 28/07/2009, 11h09

si tu développes un compilateur, j'imagine que c'est ce même compilateur que tu passes à valgrind, donc c'est bien le code du compilateur dont il s'agit.

**Dasson** · 28/07/2009, 11h19

Okay, ça fait beaucoup de lignes de code à mettre.

Voici le main du compilateur :

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
int main()
{ 
	SYMTABLE sym;	
	printf(";--\n; * LANCEMENT de yyparse()\n");  
	yyparse();
	printf(";--\n; * yyparse() TERMINE\n"); 
  	printf(";--\n; * Affichage de l'arbre syntaxique :\n");
  	printTree(root);
 	printf(";--\n; * Creation de la TDS!\n");
	sym = createSymbolTable();
	printf(";--\n; * Remplissage de la TDS :\n;--\n");
	fillSymbolTable(root,sym);
	printf(";--\n; * Verification de la specification LSD09 :\n;--\n");
	if (!check(root,sym, ALWAYS_USED)){
		freeTree(root);
		freeSymbolTable(sym);
		fprintf(stderr,"KO\n");
		exit(1);
	}
	printf(";--\n; * Fin de la verification de la specification LSD09!\n");
	printf(";--\n; * Location TDS!\n");
	computeLocations(sym);
	printf(";--\n; * Affichage de la TDS apres location :\n");
	printSymbolTable(sym);
	printSymbolTableUsed (sym);
	printf(";--\n; * Generation du pcode :\n");
	pcodeGenValue(root,sym);
	printf(";--\n; * Liberation Memoire !\n");
	freeTree(root);
	freeSymbolTable(sym);
	fprintf(stderr,"OK\n");
	return 0;
}

code des libérations de mémoires :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
 
TREE createNode(int id, int ival, char* sval, int type, int varRef, TREE left, TREE center, TREE right){
 
	TREE node = (TREE) malloc(sizeof(NODE)); // Memory for node
 
	if (node == NULL){
		printf ("; Memory node Refused Acces\n");
		return NULL;
	}
	else{
 		node->id = id;		// Identifiant du noeud
		node->ival = ival;	// Variable utilisée par Yacc
		node->sval = sval;	// Variable utilisée par Yacc
		node->type = type;	// Type du noeud
		node->varRef = varRef;	// Variable de reference - Var : 1, No Var : 0
		node->left = left;	// Pointeur left du noeud
		node->center = center;		// Pointeur center du noeud
		node->right = right;	// Pointeur right du noeud
 
		return node;
	}
}
 
STITEM * createSTNode(){
 
  	STITEM * node = (STITEM * ) malloc(sizeof(STITEM));
 
  	if (node == NULL){
      		fprintf(stderr,"KO\n");
      		printf("ERROR : cannot malloc in createSTNode()\n");
      		exit(1);
    	}
 
  	node->id = NULL;	// Identifiant du noeud	
  	node->location = NO_LOC;// location pour pcode
  	node->type = -1;	// Type du noeud
  	node->tabLenght = -1;	// Longueur du tableau si le noeud est de type tableau
	node->borneInf = -1;	// Borne inferieur du tableau si le noeud est de type tableau
	node->borneMax = -1;	// Borne superieur du tableau si le noeud est de type tableau
	node->next = NULL;	// Pointeur next du noeud
  	node->previous = NULL;	// Pointeur previous du noeud
	node->up = NULL;	// Pointeur up du noeud
	node->down = NULL;	// Pointeur down du noeud
  	node->procedure = 0;	// Variable indiquant si le noeud est une procedure
  	node->param = 0;	// Variable indiquant si le noeud est un parametre
  	node->used = NEVER_USED; //Variable qui permet de savoir si elle est toujours utilise, parfois ou jamais
 
  	return node;
}
 
SYMTABLE createSymbolTable(){
 
  	SYMTABLE s = (SYMTABLE) createSTNode();
	return s;
}
 
//Libération table des symboles
void freeSymbolTable(SYMTABLE s){
	if (s != NULL){
		if (s->down != NULL)
      			freeSymbolTable(s->down);
      		freeSymbolTable(s->next);
      		free(s);
    	}
}
 
//Liberation arbre syntaxique
void freeTree(TREE tree){
 
	if(tree != NULL){
		if(tree->center != NULL)
			freeTree(tree->center);
		if(tree->left != NULL)
			freeTree(tree->left);
		if(tree->right != NULL)
			freeTree(tree->right);
	}
	free(tree->sval);
	free(tree);
}

Voilà les codes des allocations de mémoires et de la libération. Je tiens à préciser que ces codes marchent correctement, ainsi que la libération de mémoire. Valgrind me dit que ça vient uniquement de yyparse et pas des freeTree et freeSymbolTable.

Enfin peut être que je me trompe. Si vous avez besoin d'autre chose, n'hésitez pas.

Merci bien

Dasson

**nicolas.sitbon** · 28/07/2009, 11h22

qu'est ce que tu ne comprends pas quand je dis

Envoyé par nicolas.sitbon

soit tu postes le code (compilable, pas un bout de code) si tu veux qu'on t'aide.

Tu fais une archive, tu la mets en pièce jointe et le tour est joué.

**Dasson** · 28/07/2009, 11h25

Oki doki, je ne savais pas qu'on savait mettre de piece jointe sur le forum.

Enfin voilà le compilateur complet.

Dasson

EDIT : Voici un programme test qui fonctionne avec le compilateur. Il compile uniquement un pseudo langage dont voici un programme :

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
program test5103;
var
    execution:integer;
    nombre:integer;
    fact:integer;
    a:integer;
    procedure factorielle (n:integer, var f:integer);
	var newf:integer;
 
	begin
		if(n>1) then
			factorielle(n-1,newf);
			f:=newf*n
		else
			if (not (n<0)) then
				f:=1
			else
				f:=0
			fi
		fi
	end;
begin
	execution:=0;
	while execution < 5 do
		read nombre;
		execution:=execution+1;
		factorielle (nombre, fact);
		write fact
	od	
end.

**nicolas.sitbon** · 28/07/2009, 11h36

Pas de Makefile?

**Dasson** · 28/07/2009, 11h38

Heu si pardon le voici

Le fichier est joins mais au cas où il ne passerai pas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
all:
	bison -dty LSD09-BDP.y
	flex LSD09-BDP.l
	gcc -g *.c
 
clean:
	-rm *.o *~ y.tab.c y.tab.h lex.yy.c lsd09
 
 
distclean: clean
	-rm lsd09

Dasson

Valgrind et fuite de mémoire

C

Vue hybride

Discussions similaires

Partager

Partager