Question

typedef int (D::*fptr)(void);
fptr bfunc;
bfunc=&D::Bfunc;
cout<<(reinterpret_cast<unsigned long long>(bfunc)&0xffffffff00000000)<<endl;

完整代码位于：https://ideone.com/wRVyTu

我正在尝试使用reinterpret_cast，但编译器会抛出错误

prog.cpp: In function 'int main()': prog.cpp:49:51: error: invalid cast from type 'fptr {aka int (D::*)()}' to type 'long long unsigned int'   cout<<(reinterpret_cast<unsigned long long>(bfunc)&0xffffffff00000000)<<endl;

我的问题是：

为什么reinterpret_cast不适合这种场合？
还有其他方法，我可以看到方法指针的内容吗？

Answer 1

对此有一个非常简单的答案。指针到方法不＆＃39;正常＆＃39;指针，即使通过reinterpret_cast也无法转换为指针。一个人可以先投射到void*，然后投射到long long，但这实际上是不明智的。

请记住，指针到方法的大小不一定（通常不！）等于＆＃39; normal＆＃39;的大小。指针。大多数编译器实现指针到方法的方式，它的大小是普通＆＃39;大小的两倍。指针。

GCC会抱怨在迂腐模式下向void*投射指针的方法，但仍会生成代码。

Answer 2

使用clang ++编译代码的略微修改版本（删除所有cout以获得数千行...），我们为main得到了这个：

define i32 @main() #0 {
entry:
  %retval = alloca i32, align 4
  %bfunc = alloca { i64, i64 }, align 8
  %dfunc = alloca { i64, i64 }, align 8
  store i32 0, i32* %retval, align 4
  store { i64, i64 } { i64 1, i64 16 }, { i64, i64 }* %bfunc, align 8
  store { i64, i64 } { i64 9, i64 0 }, { i64, i64 }* %dfunc, align 8
  ret i32 0
}

请注意，bfunc和dfunc是两个64位整数值。如果我为32位x86编译它是两个i32（所以32位整数值）。

所以，如果我们让main看起来像这样：

int main() {
    // your code goes here

    typedef int (D::*fptr)(void);

    fptr bfunc;
    fptr dfunc;

    bfunc=&D::Bfunc;
    dfunc=&D::Dfunc;

    D d;
    (d.*bfunc)();

    return 0;
}

生成的代码如下所示：

; Function Attrs: norecurse uwtable
define i32 @main() #0 {
entry:
  %retval = alloca i32, align 4
  %bfunc = alloca { i64, i64 }, align 8
  %dfunc = alloca { i64, i64 }, align 8
  %d = alloca %class.D, align 8
  store i32 0, i32* %retval, align 4
  store { i64, i64 } { i64 1, i64 16 }, { i64, i64 }* %bfunc, align 8
  store { i64, i64 } { i64 9, i64 0 }, { i64, i64 }* %dfunc, align 8
  call void @_ZN1DC2Ev(%class.D* %d) #3
  %0 = load { i64, i64 }, { i64, i64 }* %bfunc, align 8
  %memptr.adj = extractvalue { i64, i64 } %0, 1
  %1 = bitcast %class.D* %d to i8*
  %2 = getelementptr inbounds i8, i8* %1, i64 %memptr.adj
  %this.adjusted = bitcast i8* %2 to %class.D*
  %memptr.ptr = extractvalue { i64, i64 } %0, 0
  %3 = and i64 %memptr.ptr, 1
  %memptr.isvirtual = icmp ne i64 %3, 0
  br i1 %memptr.isvirtual, label %memptr.virtual, label %memptr.nonvirtual

memptr.virtual:                                   ; preds = %entry
  %4 = bitcast %class.D* %this.adjusted to i8**
  %vtable = load i8*, i8** %4, align 8
  %5 = sub i64 %memptr.ptr, 1
  %6 = getelementptr i8, i8* %vtable, i64 %5
  %7 = bitcast i8* %6 to i32 (%class.D*)**
  %memptr.virtualfn = load i32 (%class.D*)*, i32 (%class.D*)** %7, align 8
  br label %memptr.end

memptr.nonvirtual:                                ; preds = %entry
  %memptr.nonvirtualfn = inttoptr i64 %memptr.ptr to i32 (%class.D*)*
  br label %memptr.end

memptr.end:                                       ; preds = %memptr.nonvirtual, %memptr.virtual
  %8 = phi i32 (%class.D*)* [ %memptr.virtualfn, %memptr.virtual ], [ %memptr.nonvirtualfn, %memptr.nonvirtual ]
  %call = call i32 %8(%class.D* %this.adjusted)
  ret i32 0
}

这一点并非完全无足轻重，但在本质上：

  %memptr.adj = Read adjustment from bfunc[1]
  %2 = %d[%memptr.adj]
  cast %2 to D*
  %memptr.ptr = bfunc[0]
  if (%memptr.ptr & 1) goto is_virtual else goto is_non_virtual

is_virtual:
  %memptr.virtual=vtable[%memptr.ptr-1]
  goto common

is_non_virtual:
  %memptr.non_virtual = %memptr.ptr

common:
   if we came from 
      is_non_virtual: %8 = %memptr.non_virtual
      is_virtual: %8 = %memptr.virutal
   call %8

我跳过一些类型转换和东西以使其更简单。

注意这并不意味着＆＃34;这就是它的实现方式。它是编译器可以做的一个例子。不同的编译器会巧妙地区别对待。但是如果函数可能是虚拟的，也可能不是虚函数，编译器首先必须弄清楚哪个。 [在上面的示例中，我非常确定我们可以启用优化并获得更好的代码，但它可能只是弄清楚究竟发生了什么并删除所有代码，以便了解如何它的工作毫无意义]

如何查看方法指针的内容？

2 个答案: