static_cast involving pointers to members is too strict during constant evaluation

[Halalaluyafail3]

The following program demonstrates this issue:

consteval int foo(){
    struct A{char x;};
    struct B{char y;};
    struct C:A,B{};
    char C::*p=&A::x;
    char B::*q=static_cast<char B::*>(p);
    C c{};
    return((B&)c).*q;
}
int main(){
    return foo();
}

Clang rejects this code complaining about the static_cast, while GCC accepts it. Also, MSVC will crash with this code. This code should be fine because https://eel.is/c++draft/expr.static.cast#11.sentence-5 says "If class B contains the original member, or is a base class of the class containing the original member, the resulting pointer to member points to the original member." B here does not contain the member A::x, but it is a base class of C which contains the member.

[keinflue]

I think in "or is a base class of the class containing the original member," the phrase "the class containing the original member" is specifically meant to refer to the (unique) class of which the member is a direct member, i.e. A, of which B is not a base class.

See also e.g. Itanium C++ ABI:

It is possible to convert a member pointer to a derived class and then cast it back it to a different base class; if the second base class is stored after the first, the resulting offset will be negative. However, this cast has undefined behavior because the member is no longer a member of a base or derived class of the member pointer's class.

[Halalaluyafail3]

I think in "or is a base class of the class containing the original member," the phrase "the class containing the original member" is specifically meant to refer to the (unique) class of which the member is a direct member, i.e. A, of which B is not a base class.

See also e.g. Itanium C++ ABI:

It is possible to convert a member pointer to a derived class and then cast it back it to a different base class; if the second base class is stored after the first, the resulting offset will be negative. However, this cast has undefined behavior because the member is no longer a member of a base or derived class of the member pointer's class.

I don't see why it is meant to be interpreted like that, for example:

struct A{
    int x;
};
struct B{
    int y;
};
struct C:A,B{
    int z;
};
int A::*p;

p can obviously point at x, but why should it be able to point at z but not y?

[Halalaluyafail3]

Also, Clang doesn't seem to optimize around such assumptions e.g.:

struct A{
    int x;
};
struct B{
    int y;
};
int foo(A*p,B*q,int A::*m){
    q->y=0;
    p->*m=42;
    return q->y;
}

With -O3 this loads the value q->y instead of assuming the result is zero, which happens when using p->x=42 instead.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (Halalaluyafail3)

The following program demonstrates this issue: ```cpp consteval int foo(){ struct A{char x;}; struct B{char y;}; struct C:A,B{}; char C::*p=&A::x; char B::*q=static_cast<char B::*>(p); C c{}; return((B&)c).*q; } int main(){ return foo(); } ``` Clang rejects this code complaining about the static_cast, while GCC accepts it. Also, MSVC will crash with this code. This code should be fine because https://eel.is/c++draft/expr.static.cast#11.sentence-5 says "If class B contains the original member, or is a base class of the class containing the original member, the resulting pointer to member points to the original member." `B` here does not contain the member `A::x`, but it is a base class of `C` which contains the member.

[keinflue]

Consider the following variation:

consteval int foo() {
    struct A {
        char x;
    };
    struct B {
        char y;
    };
    struct C : A, B {};
    struct D : B, A {};
    char C::* p = &A::x; // member at offset 0 from type A and C
    char B::* q = static_cast<char B::*>(p); // member at offset -1 from type B
    char D::* p2 = static_cast<char D::*>(q); // member at offset -1 from type D
    char A::* a = static_cast<char A::*>(p2); // member at offset -2 from type A (!!)
    A x{42};
    return x.*a; // garbage
}

int main() { return foo(); }

Both GCC and Clang reject this (MSVC still crashes) and removing consteval both GCC and Clang produce a program returning a garbage value. I think with your interpretation this would need to be valid, but there is no way to keep track of the member with just an offset as the ABI does.

[Halalaluyafail3]

Consider the following variation:

consteval int foo() {
struct A {
char x;
};
struct B {
char y;
};
struct C : A, B {};
struct D : B, A {};
char C::* p = &A::x; // member at offset 0 from type A and C
char B::* q = static_cast<char B::>(p); // member at offset -1 from type B
char D:: p2 = static_cast<char D::>(q); // member at offset -1 from type D
char A:: a = static_cast<char A::*>(p2); // member at offset -2 from type A (!!)
A x{42};
return x.*a; // garbage
}

int main() { return foo(); }
Both GCC and Clang reject this (MSVC still crashes) and removing consteval both GCC and Clang produce a program returning a garbage value. I think with your interpretation this would need to be valid, but there is no way to keep track of the member with just an offset as the ABI does.

Ok, I see the issue. I'll open a bug with GCC instead for the original program.