Clang will not accept a conversion from a bound pmf(Pointer to member function) to a regular method pointer. Gcc accepts this.

[llvmbot]

Bugzilla Link	22121
Resolution	WONTFIX
Resolved on	Nov 15, 2015 15:26
Version	unspecified
OS	Windows XP
Reporter	LLVM Bugzilla Contributor
CC	@majnemer,@DougGregor

Extended Description

This code below work and combines well on Gcc. With this code I can extract any pointer to a function so that I can have Delphi style events. But Clang reports

source_file.cpp:37:3: error: cannot cast from type 'int (A::)(int)' to pointer type 'MyProc' (aka 'int ()(void )')
__methodv(int,Xyz,int y) { return 5 + y;}
^~~~~~~~~~~~~~~~~~~~~~~~
source_file.cpp:13:49: note: expanded from macro '__methodv'
virtual void _get_ptr##name() { MyProc aa = (MyProc)&this_t::name; void** bb = (void**)&aa; return bb; }
^~~~~~~~~~~~~~~~~~~~~
source_file.cpp:44:3: error: cannot cast from type 'int (B::)(int)' to pointer type 'MyProc' (aka 'int (*)(void )')
__methodv(int,Xyz,int x) {
^~~~~~~~~~~~~~~~~~~~~~~~
source_file.cpp:13:49: note: expanded from macro '__methodv'
virtual void _get_ptr##name() { MyProc aa = (MyProc)&this_t::name; void** bb = (void**)&aa; return bb; }
^~~~~~~~~~~~~~~~~~~~~
source_file.cpp:52:10: warning: unused variable 'i' [-Wunused-variable]
auto i = 5;
^
source_file.cpp:72:11: warning: unused variable 'xx' [-Wunused-variable]
void xx = a->__get_ptr_Xyz();
^
source_file.cpp:76:10: warning: unused variable 'ff' [-Wunused-variable]
auto ff = std::bind(&decltype(b)::Abc,b);
^
source_file.cpp:61:10: warning: unused variable 'method' [-Wunused-variable]
auto method = &decltype(b)::Xyz;

// END OF ERRORS

So all it has to do is look at the pmf and just give me the pointer. Once I have the pointer everything is well. A way to silence the warnings is also helpful.

// START OF CODE
#include
#include
#include
//#include <windows.h>

using namespace std;

typedef int(MyProc)(void b);

#define __cdecl

#define __methodv(type,name,...)
virtual void* _get_ptr##name() { MyProc aa = (MyProc)&this_t::name; void** bb = (void**)&aa; return *bb; }
virtual __cdecl type name( VA_ARGS ) \

template<class resultT, class A>
struct TFunction1 {
typedef __cdecl resultT (TProc)(void,A);
TProc proc;
void* instance;
TFunction1(void* _instance, void* _proc) {
proc = (TProc)_proc;
instance = _instance;
}
inline attribute((always_inline)) resultT operator()(A a) {
return proc(instance,a);
}
};

using TNotifyInts = TFunction1<int,int>;

class A {
public:
using this_t = A;
virtual int Abc() { return 0; }
__methodv(int,Xyz,int y) { return 5 + y;}
};

class B: public A {
public:
using this_t = B;
int Abc() override { return 1; }
__methodv(int,Xyz,int x) {
//printf("dfg\n");
return 5 + x;
}
};

int main()
{
auto i = 5;
cout << "Hello world!" << endl;

A* a;
B b;
a = &b;



auto method = &decltype(b)::Xyz;


typedef int(*MyProc)(void* b);


#define __PMFX(obj,method)\
  obj , obj->__get_ptr_##method()


//MyProc xx = (MyProc)&std::remove_reference<decltype((*a))>::type::Abc;
void* xx = a->__get_ptr_Xyz();
auto MyFunc1 = TNotifyInts(__PMFX(a,Xyz));

//DWORD dw = GetTickCount();
auto ff = std::bind(&decltype(b)::Abc,b);
int x = 0;
while (x < 10000000) {
  //a->Abc();

  //(((B*)a)->*method)(1);
  //xx(a);
  MyFunc1(5);
  //ff();
  x++;
}

// std::cout << GetTickCount() - dw << "\n";

// auto f = std::bind(b.Abc)

return 0;

}

Is there any way to enable this in clang or is it a bug?

[majnemer]

It's a non-conforming extension: https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Bound-member-functions.html

[llvmbot]

It's a non-conforming extension:
https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Bound-member-functions.html

Yes, it is. But there are two reasons for this to be implemented:

1. Clang aims to be a GCC drop-in replacement and mimics GCC. If it does so, I would expect it to implement all GCC's extensions, at least this one, which is probably not so complex.

2. This is a very important feature, which is impossible to replace with any other legal construct of the language. This is a huge oversight by the C++ standard committee that this feature is not available in the language. The PMF (pointer to member function) is a much more complicated and not nearly as useful construct than a pointer to bound member function, yet the former is present in the language, and the latter still isn't.

[majnemer]

It's a non-conforming extension:
https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Bound-member-functions.html

Yes, it is. But there are two reasons for this to be implemented:

1. Clang aims to be a GCC drop-in replacement and mimics GCC. If it does so,
   I would expect it to implement all GCC's extensions, at least this one,
   which is probably not so complex.

Clang aims to be as compatible as is reasonable but no closer. There are some very prominent GCC extensions which clang will never implement.

2. This is a very important feature, which is impossible to replace with any
   other legal construct of the language. This is a huge oversight by the C++
   standard committee that this feature is not available in the language. The
   PMF (pointer to member function) is a much more complicated and not nearly
   as useful construct than a pointer to bound member function, yet the former
   is present in the language, and the latter still isn't.

The feature is fundamentally broken because pointers to member functions don't result in accessing a vtable when the member function in question is non-virtual.
Consider the following:
$ cat t.cpp
extern "C" int printf(const char *, ...);

struct A {
char x;
void f() { printf("A-in-B [A::f]: %p\n", this); }
};
struct X { virtual ~X() {} char y; };
struct B : X, A {};
extern B b;
typedef void (B::*b_mp)();
typedef void (*b_fptr)(B *);

b_fptr convert(B &b, b_mp mp){
return (b_fptr)(b.*mp);
}

int main() {
B b;
b_mp mp = &A::f;
printf("B: [main]: %p\n", &b);
printf("A-in-B [main]: %p\n", (A *)&b);
(b.*mp)();
convert(b, mp)(&b);
}
$ g++ -Wno-pmf-conversions t.cpp -o t && ./t
B: [main]: 0x7ffde0a7c9f0
A-in-B [main]: 0x7ffde0a7c9f9
A-in-B [A::f]: 0x7ffde0a7c9f9
A-in-B [A::f]: 0x7ffde0a7c9f0

The last printf didn't correctly print out the address of the A-in-B subobject of B. This is because GCC can't rely on the fact that there exists a B-to-A thunk which will perform the this adjustment for us.

[llvmbot]

The feature is fundamentally broken because pointers to member functions
don't result in accessing a vtable when the member function in question is
non-virtual.
...
The last printf didn't correctly print out the address of the A-in-B
subobject of B. This is because GCC can't rely on the fact that there
exists a B-to-A thunk which will perform the this adjustment for us.

Well, it gets even funnier, but it looks like a GCC bug to me. If this feature is unfixable, they should have removed it and stopped announcing it in their docs.

They could have just avoided using PMFs altogether and allowed this expression: &(object.func).

I guess now I should file a bug to GCC.

[llvmbot]

The feature is fundamentally broken because pointers to member functions
don't result in accessing a vtable when the member function in question is
non-virtual.
Consider the following:
$ cat t.cpp
extern "C" int printf(const char *, ...);

struct A {
char x;
void f() { printf("A-in-B [A::f]: %p\n", this); }
};
struct X { virtual ~X() {} char y; };
struct B : X, A {};
extern B b;
typedef void (B::*b_mp)();
typedef void (*b_fptr)(B *);

b_fptr convert(B &b, b_mp mp){
return (b_fptr)(b.*mp);
}

int main() {
B b;
b_mp mp = &A::f;
printf("B: [main]: %p\n", &b);
printf("A-in-B [main]: %p\n", (A *)&b);
(b.*mp)();
convert(b, mp)(&b);
}
$ g++ -Wno-pmf-conversions t.cpp -o t && ./t
B: [main]: 0x7ffde0a7c9f0
A-in-B [main]: 0x7ffde0a7c9f9
A-in-B [A::f]: 0x7ffde0a7c9f9
A-in-B [A::f]: 0x7ffde0a7c9f0

The last printf didn't correctly print out the address of the A-in-B
subobject of B. This is because GCC can't rely on the fact that there
exists a B-to-A thunk which will perform the this adjustment for us.

Try the code below (Note the change in the comment marked with "!!!!!!!!!!").
It works.
Also try uncommenting the /virtual/ in line 5.

extern "C" int printf(const char *, ...);

struct A {
char x;
/virtual/ void f() { printf("A-in-B [A::f]: %p\n", this); }
};
struct X { virtual ~X() {} char y; };
struct B : X, A {
void f() { printf("Virtu: [B::f]: %p\n", this); }
};
extern B b;
typedef void (B::*b_mp)();
typedef void (*b_fptr)(A *); // param A * !!!!!!!!!!

b_fptr convert(B &b, b_mp mp){
return (b_fptr)(b.*mp);
}

int main() {
B b;
b_mp mp = &A::f;
printf("B: [main]: %p\n", &b);
printf("A-in-B [main]: %p\n", (A *)&b);
(b.*mp)();
convert(b, mp)(&b);
}

[llvmbot]

The feature is fundamentally broken because pointers to member functions
don't result in accessing a vtable when the member function in question is
non-virtual.

The reason why the gcc extension https://gcc.gnu.org/onlinedocs/gcc-4.9.0/gcc/Bound-member-functions.html is unsatisfactory, is that you largely have to have a function pointer that spells out the exact desired class as the first argument:

typedef void (*b_fptr)(A *); // param A * !!!!!!!!!!

That's unsatisfactory, since you cannot use that to create an array of function pointers of same signature e.g. void() , but differing Class-types, e.g. &A::f, &B::f, &C::f where A, B and C are different types.

But this should be possible. And it is possible.
Just see Don Clugston's classic example:

https://github.com/dreamcat4/FastDelegate/blob/7d78e9a96f200036dbb2168bd62264f0022e88be/Demo.cpp#L79

where funclist is an array that takes individual items such as

https://github.com/dreamcat4/FastDelegate/blob/7d78e9a96f200036dbb2168bd62264f0022e88be/Demo.cpp#L99

and

https://github.com/dreamcat4/FastDelegate/blob/7d78e9a96f200036dbb2168bd62264f0022e88be/Demo.cpp#L119

[llvmbot]

That's unsatisfactory, since you cannot use that to create an array of
function pointers of same signature e.g. void() , but differing
Class-types, e.g. &A::f, &B::f, &C::f where A, B and C are different types.
Just briefly: It turns out, that that statement is incorrect!
See code here https://github.com/ajneu/delegate_experiments/blob/master/gcc_pmf_2/pmf_gcc_demo.cpp
(The type is codified into a static function, which static_cast's the void* to that type -- https://github.com/ajneu/delegate_experiments/blob/2f9553687a774eb3dfc0c9b43959e369ca96eacb/gcc_pmf_2/pmf_gcc_demo.cpp#L38 ).
(That uses the gcc specifig Bound-member-functions)