Edit valgrind y amigos (Clang Static Analyzer, LLVM "Klee", C-Semantics tool)

Title:

Last edited: 5:03:53 pm on 16 May 2011 by salchicha

De *esta página>http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html*:

===CUT===
1. The *Valgrind>http://valgrind.org/* *memcheck tool>http://valgrind.org/info/tools.html#memcheck* is a fantastic way to find all sorts of uninitialized variables and other memory bugs. Valgrind is limited because it is quite slow, it can only find bugs that still exist in the generated machine code (so it can't find things the optimizer removes), and doesn't know that the source language is C (so it can't find shift-out-of-range or signed integer overflow bugs).

2. Clang has an experimental <tt>-fcatch-undefined-behavior</tt> mode that inserts runtime checks to find violations like shift amounts out of range, some simple array out of range errors, etc.

3. Compiler warning messages are good for finding some classes of these bugs, like uninitialized variables and simple integer overflow bugs. It has two primary limitations: 1) it has no dynamic information about your code as it executes, and 2) it must run very quickly because any analysis it does slows down compile time.

4. The *Clang Static Analyzer>http://clang-analyzer.llvm.org/* performs a much deeper analysis to try to find bugs (including use of undefined behavior, like null pointer dereferences). You can think of it as generating souped up compiler warning messages, because it is not bound by the compile time constraints of normal warnings. The primary disadvantages of the static analyzer is that it 1) doesn't have dynamic information about your program as it runs, and 2) is not integrated into normal workflows for many developers (though its integration into Xcode 3.2 and later is fantastic).

5. The *LLVM "Klee" Subproject>http://klee.llvm.org/* uses symbolic analysis to "try every possible path" through a piece of code to find bugs in the code and it produces a testcase. It is a great little project that is mostly limited by not being practical to run on large-scale applications.

6. While I have never tried it, the *C-Semantics>http://code.google.com/p/c-semantics/* tool by Chucky Ellison and Grigore Rosu is a very interesting tool that can apparently find some classes of bugs (such as sequence point violations). It is still a research prototype, but may be useful for finding bugs in (small and self-contained) programs. I recommend reading *John Regehr's post about it>http://blog.regehr.org/archives/523* for more information.
===CUT===

- lock this page
- enter new password
- reenter same password

Send e-mail alerts to these addresses upon next save: