Valgrind
I'm trying to install Valgrind on a Mac with Snow Leopard but am getting an error. This is what I'm typing into Terminal. $ curl -O http://valgrind.org/downloads. Valgrind documentation: Installation or Setup. Valgrind is GPLv2-licensed collection of dynamic analysis tools, which uses binary instrumentation (dynamic recompilation). Six tools are included to detect memory management (Memcheck) and threading errors (Helgrind and DRD), to generate call-graph and profile programs (with optional cache and branch-prediction simulation - Cachegrind. I tried to install Valgrind with command brew install Valgrind and I get a message says: 'valgrind: This formula either does not compile or function as expected on macOS versions newer than Sier.
Introduction
Although C is a very useful and powerful language, it can be hard to debug. A particular problem that you have probably encountered at some point is memory errors. We have already talked about gdb, which can be a helpful resource if your program consistently crashes or outputs a wrong result. However, sometimes you suspect that the problem you are having is due to a memory error, but it does not cause a segfault and you do not want to set a lot of breakpoints and step through in gdb. Another common problem you might encounter is a program with a memory leak: somewhere, you call malloc but never call free. Valgrind is a program that will help you fix both problems.
Valgrind is installed on the department machines. To invoke it on an executable called a.out, you simply run the command valgrind ./a.out (with any arguments your program might need). As when using gdb, you will want to make sure to compile your program with the flag -g, so that you can see line numbers in the output. You may also wish to debug with optimizations turned off (-O0), since if you have them on, line numbers may be inaccurate and you may occasionally encounter false alarms.
Example 1: reading/writing past the end of an array
One common mistake is accessing elements past the end of an array. Unlike java, which will throw an exception when you try that, your C program might segfault, or it might continue running, producing a result which is correct or incorrect -- sometimes with results varying between executions. This makes it hard to locate this kind of problem. Here is how you would use valgrind to find the bug:
| Example 1 | Output |
|---|
Your output might be slightly different, depending on the machine and version of valgrind and libraries installed, but should include the same types of errors. If you examine the output, you will see that there is 1 error listed (you do not need to worry about suppressed errors). Valgrind prints what the error was (Invalid write of size 4) as well as the stack. It also lists the file, function and line where this array was malloc'd.
Example 2: reading uninitialized memory
Another common problem is forgetting to initialize a variable or array before using it.
| Example 2 | Output |
|---|
Observe that the output of the program and the output of valgrind are interleaved; to get around that, it is handy to redirect the output to a separate file. This time the errors reported are for uninitialized values, and valgrind indicates where the access takes place (line 11 of example2.c). If you run with the option --track-origins=yes, valgrind will give additional information about where the uninitialized values came from.
Example 3: memory leaks
Valgrind includes an option to check for memory leaks. With no option given, it will list a heap summary where it will say if there is any memory that has been allocated but not freed. If you use the option --leak-check=full it will give more information.
| Example 3 | Output |
|---|
If you see leaks indicated as still reachable, this generally does not indicate a serious problem since the memory was probably still in use at the end of the program. However, any leaks listed as 'definitely lost' should be fixed (as should ones listed 'indirectly lost' or 'possibly lost' -- 'indirectly lost' will happen if you do something like free the root node of a tree but not the rest of it, and 'possibly lost' generally indicates the memory is actually lost). An example of where you might run into an example like the one above is if you have a function that allocates a buffer (perhaps to store a string) and returns it, but the caller never frees the memory after it is finished. If a program like that runs for a long time, it will allocate a lot of memory that it does not need.
What valgrind is NOT
Although valgrind is an extremely useful program, it will not miraculously tell you about every memory bug in your program. There are several limitations that you should keep in mind. It does not do bounds checking on stack/static arrays (those not allocated with malloc), so it is possible to have a program that behaves badly while not generating any valgrind errors. For example:
This program has a memory error, resulting in the value of x being 10 at the end rather than 0. However, valgrind will not report any errors.
A more serious limitation that you will encounter is that valgrind checks programs dynamically -- that is, it checks during actual program execution whether any leaks actually occurred for that execution. This means that if you run valgrind on a particular set of inputs that does not cause any bad memory accesses or memory to be leaked, valgrind will not report any errors, even though your program does contain bugs. As an example:
This program has a bug: if the user inputs a long string, the buffer str will overflow. Please note that you should never, ever use gets, for exactly this reason. If you run this program through valgrind, you will get a memory error if you type in a string longer than 10 characters. However, if you type in a shorter string, valgrind will report no errors, even though the program is buggy! If you want to be reasonably sure that you are catching all memory bugs, you should run valgrind on a variety of inputs, especially corner cases, as those are where you are most likely to have made a mistake like accessing past the bounds of an array.
How To Use Valgrind
When fixing errors, it is a good idea to start at the top; fixing an error that occurs earlier is likely to eliminate a lot of later errors as well.
Once in a great while you may encounter a false positive -- an error even though there is nothing wrong with your program. However, in the vast majority of cases, any error reported is real and you should fix it. Be very wary about dismissing an error as a 'false positive,' since it is much more likely that you have made a mistake.
One final thing to note about valgrind is that your programs will take longer to execute (like 20 to 30 times as long), and will also use more memory.
More information
How To Download Valgrind On Mac Windows 10
If you are curious about valgrind, you can check the valgrind website, especially the FAQ.
How To Download Valgrind On Mac Version
Please send any corrections or questions to lena@cs. Last updated 16 March 2011.