To get a trial key
fill out the form below
Team License (a basic version)
Enterprise License (an extended version)
* By clicking this button you agree to our Privacy Policy statement

Request our prices
New License
License Renewal
--Select currency--
USD
EUR
RUB
* By clicking this button you agree to our Privacy Policy statement

Free PVS-Studio license for Microsoft MVP specialists
* By clicking this button you agree to our Privacy Policy statement

To get the licence for your open-source project, please fill out this form
* By clicking this button you agree to our Privacy Policy statement

I am interested to try it on the platforms:
* By clicking this button you agree to our Privacy Policy statement

Message submitted.

Your message has been sent. We will email you at


If you haven't received our response, please do the following:
check your Spam/Junk folder and click the "Not Spam" button for our message.
This way, you won't miss messages from our team in the future.

>
>
What's the Difference Between Static An…

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

Aug 18 2014

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.

0274_AnalyzerWarning/image1-cbc4010049d1ed585a830edf3ede869b.png

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

Conclusion

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.

Comments (0)

Next comments
This website uses cookies and other technology to provide you a more personalized experience. By continuing the view of our web-pages you accept the terms of using these files. If you don't want your personal data to be processed, please, leave this site.
Learn More →
Accept