Is the compiler allowed to optimize out dynamic_cast of a volatile pointer when the compiler doesn't see a possible type which can fulfill the cast?

Question

Look at this little snippet:

struct A {
    virtual ~A() { }
};

struct B { };

bool fn() {
    A *volatile a = new A;
    return dynamic_cast<B *>(a); 
}

Is the compiler allowed to remove the dynamic_cast altogether, and transform dynamic_cast to a simple nullptr;?

The reason of this question is this answer.

Notes:

• Assume that volatile means that the compiler cannot assume anything about a, because it's volatile. Here's a question why.

• The fact that dynamic_cast may not be allowed to be removed is that there could be a type somewhere in the program, which derives from both A and B.

Answer 1

Yes. dynamic_cast has no observable behavior beyond its return value.

The compiler is aware of the static type pointed to by a.

So under the as-if rule, the compiler is free to evaluate the dynamic cast at compile time.

In fact:

struct A { virtual ~A() {} };
struct B:A {};

bool foo() {
  A* a = new A;
  return dynamic_cast<B*>(a);
}

the above dynamic cast statement can also be optimized to return false; The new cannot be omitted without whole program optimization as someone could overload the global operator new; once it is proven that no global operator new is overloaded, it could even optimize out the call to new A, as neither allocating memory by the default operator new, nor creating an A nor destroying one has any observable side effects.

Answer 2

Yes, a compiler can omit the call to dynamic_cast as per as-if rule ¹⁾ if and only if it can prove that the only valid result of the call is false. That's simple.

The tricky part is to prove that the only valid result of dynamic_cast is false. You can prove that iff there is no class in your whole program that inherits both from A and B.

Now I am not very versed in this part, but I think you can do that when you create the binary and have all the types in your program only if it's an executable (not a library) and only if the program doesn't dynamically link to other libraries.

---

¹⁾ the dynamic_cast on pointers doesn't have side effect, it doesn't throw