News for hackers. Stuff that matters.
Re:Null Pointer Dereferencing Causes Undefined Behavior by pcwalton on Monday April 20, 2015 @06:14PM (#9411181)
Being able to assume that a pointer is not null opens up some really interesting optimizations. For example, if you know that a pointer is dereferenceable, then you can speculatively hoist loads of it out of a loop as long as there are no possibly-aliasable pointer stores in between. That's why it's helpful for C compilers to be able to aggressively infer that pointers are not null.
Re:Null Pointer Dereferencing Causes Undefined Behavior by ufo on Monday April 20, 2015 @08:40PM (#9411702)
Just wondering: how much do these particular optimizations end up being worth in the end? Is it something noticeable or is it like array bounds checking where its almost always OK to leave the checks in the end?
Re:Null Pointer Dereferencing Causes Undefined Behavior by joosters on Monday April 20, 2015 @09:18PM (#9411794)
It's impossible to give a general answer. You could have a tight loop in a performance critical part of your code, where optimising out the NULL check removes (say) 25% of the loop code. Or, the check might be negligible. It depends upon the code.

That's why IMO people saying that the compiler shouldn't bother with these 'excessive' optimisations are wrong. It might be worthless for them and their programs, but might be valuable for others. Don't force your priorities upon other people.

Re:Null Pointer Dereferencing Causes Undefined Behavior by pcwalton on Monday April 20, 2015 @09:43PM (#9411857)
Yes. I'd also add that loop optimizations tend to magnify in importance when you consider that the loop might be vectorized. Especially since the state of scatter/gather SIMD intrinsics is so poor at the moment...
Re:Null Pointer Dereferencing Causes Undefined Behavior by jwatte on Monday April 20, 2015 @10:45PM (#9412007)
This is entirely wrong. Taking the address of a field doesn't evaluate the field, and any compiler that does a load for that is broken.
Re:Null Pointer Dereferencing Causes Undefined Behavior by pcwalton on Monday April 20, 2015 @11:24PM (#9412126)
Where it kicks in is code like this:

    ... &p[1].foo ...
    for (int i = 0; i < ...; i++) {
        bar += p[0].foo;
    }
The compiler wants to transform the loop as follows:

    auto tmp = p[0].foo;
    for (int i = 0; i < ...; i++) {
        bar += tmp;
    }
Assume that the compiler cannot prove that the loop will execute at least once. Now observe that this transformation is correct if and only if the pointer p is dereferenceable (with the offset of the field foo applied). The optimization would miscompile a perfectly valid program if p were NULL and the loop ran zero times. And because of strict-aliasing rules, the only way that p would not be dereferenceable in this way is if it were NULL or one element beyond the end of an array.

So the compiler wants to prove that p is not NULL upon entry to the loop. And in this program, it can--because of the address computation, the behavior is undefined if p is NULL or one element beyond the end of an array. Therefore, the compiler can safely assume that p is not NULL and perform the loop invariant code motion. In this program, it can only do so thanks to the rule about undefined behavior in address computations.

Note that I'm not aware of any compiler that actually does this, because the C++ standard committee seems to consider this undefined behavior an oversight in the spec (per the discussion linked there). But the OP successfully argues that it could, per a lawyer-y reading of the spec.

Edit: Argh, I missed the case in which p was one element beyond the end of an array. Updated.

Re:Null Pointer Dereferencing Causes Undefined Behavior by nkurz on Tuesday April 21, 2015 @04:41AM (#9412850)
I like your detailed example, but wouldn't a slightly kinder but equally optimizing compiler simply add a conditional before the load:

  if (max > 0) {
    int i = max; 
    int tmp = p[0].foo;
    do {
       bar += tmp;
    } while (--i);
  }
I'd even argue the assembly is slightly better when interpreted this way, since branch prediction will tend execute the load or not as appropriate, rather than potentially taking a unnecessary TLB miss for a load that's never used.