My program was always returns a segmentation fault, but I couldn't understand why so tried to debug with GDB and it showed me this:
(gdb) backtrace
#0 0x001a98ef in _int_malloc (av=0x2d8440, bytes=8) at malloc.c:3835
#1 0x001abedc in __GI___libc_malloc (bytes=8) at malloc.c:2924
#2 0x0804cd6a in init_capsula (item1_=2, item2_=2)
at src/modulos/modulos_auxiliares/capsula/capsula.c:25
#3 0x0804d366 in total_dados_produto (f=0x8055838, filial=0x0, mes=6,
cod=0xbffff23c "AF1184") at src/modulos/faturacao/faturacao.c:208
#4 0x0804b237 in queries (q=3, c1=0x0, c2=0x0, f=0x8055838, v=0x0) at src/interface.c:815
#5 0x0804b6f4 in menu (c1=0x8055008, c2=0x8055420, f=0x8055838, v=0x0) at src/interface.c:976
#6 0x080487ad in main () at src/interface.c:1037
I then identified the source of the problem coming from frame 2 so decided to check that out and got the following output:
(gdb) frame 2
#2 0x0804cd6a in init_capsula (item1_=2, item2_=2)
at src/modulos/modulos_auxiliares/capsula/capsula.c:25
25 c->item1 = (int*) malloc((sizeof (int))*item1_);
It tells me malloc is returning a NULL, however I can't see the problem with this line, everything is proprely initialized as I confirmed with my next action:
(gdb) print ((sizeof (int))*item1_)
$1 = 8
Why can't malloc allocate a such tiny amount of space? Am I overlooking something really stupid here?
I will put the function init_capsula here (the one where that malloc is) for you guys to see:
Capsula init_capsula(int item1_, int item2_){
Capsula c = (Capsula) malloc (sizeof (struct capsula));
c->tipo = -1;
if (item1_ > 0)
c->item1 = (int*) malloc((sizeof (int))*item1_); /*Problematic line*/
else c->item1 = NULL;
if (item2_ > 0)
c->item2 = (float*) malloc((sizeof (float))*item2_);
else c->item2 = NULL;
c->q1 = 0;
c->q2 = 0;
return c;
}
Capsula is a pointer to a struct defined like this:
struct capsula{
int tipo;
int q1;
int *item1;
int q2;
float *item2;
};
EDIT:
if I try to run with valgrind using the following command:
valgrind --tool=memcheck --leak-check=full make run
It outputs this, which I don't find very helpful.
make: *** [run] Segmentation fault (core dumped)
==5848==
==5848== HEAP SUMMARY:
==5848== in use at exit: 62,771 bytes in 1,819 blocks
==5848== total heap usage: 6,060 allocs, 4,241 frees, 580,609 bytes allocated
==5848==
==5848== LEAK SUMMARY:
==5848== definitely lost: 0 bytes in 0 blocks
==5848== indirectly lost: 0 bytes in 0 blocks
==5848== possibly lost: 0 bytes in 0 blocks
==5848== still reachable: 62,771 bytes in 1,819 blocks
==5848== suppressed: 0 bytes in 0 blocks
==5848== Reachable blocks (those to which a pointer was found) are not shown.
==5848== To see them, rerun with: --leak-check=full --show-reachable=yes
==5848==
==5848== For counts of detected and suppressed errors, rerun with: -v
==5848== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
EDIT2:
I finally understood the problem by using valgrind correctly as I was using it on make when I should be using it on the program itself (as indicated in the comments). The problem was on a very different place, on a place I forgot to write a malloc, thanks for everyone that helped, now I finally understand how I should use valgrind
I am answering to my own question because, as I said on my last edit, I found my answer with help from the comments.
I finally understood the problem by using valgrind correctly as I was using it on make when I should be using it on the program itself (as indicated on the comments). The problem was on a very different place, on a place I forgot to write a malloc so there is no need to get into details about that, thanks for everyone that helped, now I finally understand how I should use valgrind