Why does valgrind not show the obvious leaks in my program? [closed]

Question

This question needs debugging details . It is not currently accepting answers.

---

Update the question so it's on-topic for Stack Overflow.

Closed 7 months ago .

Improve this question

As I was compiling a program in which I used malloc twice, I realised that I forgot to free the allocated memory at the end of the program.

Having recently encountered the Valgrind tool, I thought it would be a nice occasion to run it to see how it displays memory leaks errors. But to my surprise, Valgrind returned that all heaps blocks were freed...

Valgrind results

The only thing I can think of is that the mallocs were not in the main function but in a subordinate function. But I don't think that Valgrind would be restricted to main, would it

I have tried to find an answer in Valgrind documentation, but to no avail.

Here is the complete code as requested, the aim of which is to cipher a text thanks to a 26 letters key provided by the user as a command line argument.

#include <stdio.h>
#include <cs50.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>

void cipher(char *, char *);

int main(int argc, char *argv[])
{
    if (argc != 2)
    {
        printf("Usage: ./substitution key\n");
        return 1;
    }

    //INPUT
    char *p = get_string("plaintext: ");

    //OUTPUT
    cipher(argv[1], p);
    return 0;
}

void cipher(char *a, char *b)
{
    char *low = malloc(27 * sizeof(char));
    for (int i = 0; i < 27; i++)
    {
        if (islower(a[i]))
        {
            low[i] = a[i];
        }
        else
        {
            low[i] = (a[i] + 32);
        }
    }

    char *upp = malloc(27 * sizeof(char));
    for (int i = 0; i < 27; i++)
    {
        if (isupper(a[i]))
        {
            upp[i] = a[i];
        }
        else
        {
            upp[i] = a[i] - 32;
        }
    }

    printf("ciphertext: ");

    for (int i = 0, l = strlen(b); i < l; i++)
    {
        if (islower(b[i]))
        {
            printf("%c", low[(int)b[i]-97]);
        }
        else if (isupper(b[i]))
        {
            printf("%c", upp[(int)b[i]-65]);
        }
        else
        {
            printf("%c", b[i]);
        }
    }
}

Answer 1

After all those comments, the answer is kind of silly...

Your screenshot shows you ran valgrind./substitution , without passing any command line arguments to your program. When this happens it prints Usage: ./substitution key and exits without doing anything further; in particular without calling cipher() and thus without ever calling malloc() . So of course there is no memory leak in this case.

If you run the program with a key argument on the command line, and give it some input, you should see valgrind report the memory leak:

==15815== 
==15815== HEAP SUMMARY:
==15815==     in use at exit: 54 bytes in 2 blocks
==15815==   total heap usage: 4 allocs, 2 frees, 2,102 bytes allocated
==15815== 
==15815== LEAK SUMMARY:
==15815==    definitely lost: 54 bytes in 2 blocks
==15815==    indirectly lost: 0 bytes in 0 blocks
==15815==      possibly lost: 0 bytes in 0 blocks
==15815==    still reachable: 0 bytes in 0 blocks
==15815==         suppressed: 0 bytes in 0 blocks
==15815== Rerun with --leak-check=full to see details of leaked memory

Although in principle a compiler could optimize out the malloc calls, in my tests with gcc and clang with -O3 , I couldn't find any indication of them actually doing so.