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

** This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
Request our prices
New License
License Renewal
--Select currency--
USD
EUR
GBP
RUB
* By clicking this button you agree to our Privacy Policy statement

** This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
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.

>
>
>
Reflections on the Null Pointer Derefer…

Reflections on the Null Pointer Dereferencing Issue

Jan. 15, 2015
Author:

As I have recently found out, the question whether or not the code &((T*)(0)->x) is correct appears to be quite complicated. I decided to write a small post on this subject.

In my recent article about a Linux kernel check done by the PVS-Studio analyzer, I mentioned having come across the following code fragment in the kernel's code:

static int podhd_try_init(struct usb_interface *interface,
        struct usb_line6_podhd *podhd)
{
  int err;
  struct usb_line6 *line6 = &podhd->line6;

  if ((interface == NULL) || (podhd == NULL))
    return -ENODEV;
  ....
}

I also wrote in that article that this code was incorrect in my opinion. See the article for details.

After publishing it, I got piles of emails, people telling me I had been wrong and the code was absolutely correct. Many pointed out that if podhd == 0, then the code in fact implemented the "offsetof" idiom, so nothing terrible could possibly occur. For me not to write numbers of individual replies, I decided to write one answer for everyone in the form of a small blog post.

Naturally, I did a deeper investigation of the subject. But honestly, I only grew confused even more. So I can't give you an exact answer whether or not you can write code like that; I will only share some links and my own considerations with you.

When writing that article about the Linux check, I was thinking in the following way.

Any null pointer dereferencing operation is undefined behavior. One of the consequences of undefined behavior may be such code optimization that can result in removing the (podhd == NULL) check. It was this scenario that I described in the article.

In their letters, some developers told me they had failed to reproduce the same behavior on their compilers. But it still doesn't prove anything. The program's expected correct behavior is just one of the cases of undefined behavior.

Some also pointed out to me that the ffsetof() macro is implemented in exactly the same manner:

#define offsetof(st, m) ((size_t)(&((st *)0)->m))

But it doesn't prove anything either. Such macros are deliberately implemented so that they could work correctly on certain compilers. If we write a similar code, it won't necessarily work right.

Moreover, in the example with the macro, the compiler is directly handling 0 and therefore can guess what the programmer wants it to do. But when 0 is stored in a variable, it's just quite a different story and the compiler may respond unpredictably.

This is what Wikipedia has to say about offsetof:

The "traditional" implementation of the macro relied on the compiler being not especially picky about pointers; it obtained the offset of a member by specifying a hypothetical structure that begins at address zero:

#define offsetof(st, m) ((size_t)(&((st *)0)->m))

This works by casting a null pointer into a pointer to structure st, and then obtaining the address of member m within said structure. While this works correctly in many compilers, it has undefined behavior according to the C standard, since it involves a dereference of a null pointer (although, one might argue that no dereferencing takes place, because the whole expression is calculated at compile time). It also tends to produce confusing compiler diagnostics if one of the arguments is misspelled. Some modern compilers (such as GCC) define the macro using a special form instead, e.g.

#define offsetof(st, m) __builtin_offsetof(st, m)

As you can see, I am right according to what is said in Wikipedia: you can't write code like that; this is undefined behavior. Some programmers at the StackOverflow site also agree with that: Address of members of a struct via NULL pointer.

But I am still embarrassed by the fact that while everyone is talking of undefined behavior I can't find an exact explanation on the subject anywhere. For instance, that extract from the Wikipedia article has the 'citation needed' mark.

There were numerous debates on similar issues on forums, but I haven't found any clear and plain explanation supported by references to the C or C++ standards there.

There is also one old discussion of the standard which hasn't clarified the point either: 232. Is indirection through a null pointer undefined behavior?

So, I haven't come to any certain final conclusion regarding this issue so far. But I still believe that code is bad and should be refactored.

If anyone happens to have any good considerations and facts on the subject, please share them with me and I'll add them at the end of this article.

Popular related articles
Static analysis as part of the development process in Unreal Engine

Date: 06.27.2017

Author: Andrey Karpov

Unreal Engine continues to develop as new code is added and previously written code is changed. What is the inevitable consequence of ongoing development in a project? The emergence of new bugs in th…
The way static analyzers fight against false positives, and why they do it

Date: 03.20.2017

Author: Andrey Karpov

In my previous article I wrote that I don't like the approach of evaluating the efficiency of static analyzers with the help of synthetic tests. In that article, I give the example of a code fragment…
PVS-Studio ROI

Date: 01.30.2019

Author: Andrey Karpov

Occasionally, we're asked a question, what monetary value the company will receive from using PVS-Studio. We decided to draw up a response in the form of an article and provide tables, which will sho…
How PVS-Studio Proved to Be More Attentive Than Three and a Half Programmers

Date: 10.22.2018

Author: Andrey Karpov

Just like other static analyzers, PVS-Studio often produces false positives. What you are about to read is a short story where I'll tell you how PVS-Studio proved, just one more time, to be more atte…
PVS-Studio for Java

Date: 01.17.2019

Author: Andrey Karpov

In the seventh version of the PVS-Studio static analyzer, we added support of the Java language. It's time for a brief story of how we've started making support of the Java language, how far we've co…
Characteristics of PVS-Studio Analyzer by the Example of EFL Core Libraries, 10-15% of False Positives

Date: 07.31.2017

Author: Andrey Karpov

After I wrote quite a big article about the analysis of the Tizen OS code, I received a large number of questions concerning the percentage of false positives and the density of errors (how many erro…
Appreciate Static Code Analysis!

Date: 10.16.2017

Author: Andrey Karpov

I am really astonished by the capabilities of static code analysis even though I am one of the developers of PVS-Studio analyzer myself. The tool surprised me the other day as it turned out to be sma…
Free PVS-Studio for those who develops open source projects

Date: 12.22.2018

Author: Andrey Karpov

On the New 2019 year's eve, a PVS-Studio team decided to make a nice gift for all contributors of open-source projects hosted on GitHub, GitLab or Bitbucket. They are given free usage of PVS-Studio s…
The Ultimate Question of Programming, Refactoring, and Everything

Date: 04.14.2016

Author: Andrey Karpov

Yes, you've guessed correctly - the answer is "42". In this article you will find 42 recommendations about coding in C++ that can help a programmer avoid a lot of errors, save time and effort. The au…
Technologies used in the PVS-Studio code analyzer for finding bugs and potential vulnerabilities

Date: 11.21.2018

Author: Andrey Karpov

A brief description of technologies used in the PVS-Studio tool, which let us effectively detect a large number of error patterns and potential vulnerabilities. The article describes the implementati…

Comments (0)

Next comments

This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.
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