What's the Difference Between Static Analysis and Compiler Warnings?


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.

Picture 2

Analysis by compilers

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.

Third-party analyzers

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.

Explaining the point by the example of Visual C++ Compiler and PVS-Studio

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];
  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];
  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:

  • Code analysis is not the compiler's primary task.
  • Using different compilers for analysis is difficult yet advisable.
  • Compilers span a narrow range of most common bugs.
  • Static analyzers only specialize in code analysis.
  • Static analyzers provide a wide range of diagnostic rules.
  • Certain diagnostics imply inevitable false positives due to their nature.
  • You can use different analyzers independently, regardless of what compiler you use.

Using a number of static analysis tools which provide different analysis methodologies will surely improve your program's quality.

Use PVS-Studio to search for bugs in C, C++, and C# code

We offer you to check your project code with PVS-Studio. Just one bug found in the project will show you the benefits of the static code analysis methodology better than a dozen of the articles.

goto PVS-Studio;

Do you make errors in the code?

Check your code
with PVS-Studio

Static code analysis
for C, C++, and C#

goto PVS-Studio;