Our website uses cookies to enhance your browsing experience.
Your message has been sent. We will email you at
If you do not see the email in your inbox, please check if it is filtered to one of the following folders:
Webinar: Evaluation - 05.12
Visiting forums, you can often meet people who believe that compiler warnings are more than enough for controlling the basic types of errors in programs' code. I want to show you that it's a wrong belief.
Specialized static analysis tools and standard compiler warnings are both oriented towards improving the quality of the source code and minimizing potential bugs which are difficult to catch through debugging. One way or another, the compiler relies on static analysis of the source code during compilation to generate its warnings, but the quality of diagnostics and their scope of use vary greatly from one analysis method to another.
The compiler's primary task is to get binary code from compilable source files. Compilation speed is one of its most crucial characteristics, so the compiler cannot spend enough time on static analysis of source code to carry out deep analysis or provide a wide variety of diagnostic rules. That's why you can only expect compilers to inform you about the most common issues in code.
As products by different manufacturers, many compilers greatly vary in their capabilities of diagnosing suspicious code fragments, so using different compilers at a time will help you improve the quality of your programs too. But in most cases you cannot compile one program by different compilers even for one operating system. Some compilers may provide their own language extensions other compilers don't support, which makes your source code less portable. Besides, using platform-dependent constructs makes the program harder to analyze by another compiler focused solely on some other operating system.
Things are quite different with specialized static analysis tools. Since they focus on one sort of tasks only, these tools are more flexible and mature in the static analysis area. Unlike compilers, static analyzers provide more diagnostic rules, many of which can diagnose very specific and uncommon bugs.
The Visual C++ compiler has the C4265 diagnostic that generates warnings when a class is declared without a virtual destructor. This is an extremely useful diagnostic but it will generate the warning on every class without a virtual destructor, so it is disabled by default.
A similar diagnostic rule V599 is provided by the PVS-Studio analyzer. Since it is a specialized tool, the analyzer utilizes a smarter algorithm to generate the warning only if the base constructor contains at least one virtual function and an object of this class is destroyed by the delete operator.
The next example concerns the use of the memset function. Take a look at the code sample below.
void Foo()
{
char password[MAX_PASSWORD_LEN];
InputPassword(password);
ProcessPassword(password);
memset(password, 0, sizeof(password));
}The programmer intends to clear a buffer containing a password. This code is totally correct from the compiler's viewpoint; however, it will delete the call of the memset function without any warning if you launch it with the "/O2" switch. PVS-Studio uses the V597 diagnostic to find issues like that.
The correct code should look as follows:
void Foo()
{
char password[MAX_PASSWORD_LEN];
InputPassword(password);
ProcessPassword(password);
RtlSecureZeroMemory(password, sizeof(password));
}To clear the buffers with private data, you need to use a special function RtlSecureZeroMemory.
As a conclusion, let's point out the main aspects of the source code static analysis means:
Using a number of static analysis tools which provide different analysis methodologies will surely improve your program's quality.
0
0
0
0