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

Question

Closed. This question needs debugging details. It is not currently accepting answers.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
Closed 2 years 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.