c ++虚拟表查找 - 它如何搜索和替换

Question

举个例子：

class Base{
    virtual string function1(){ return "Base - function1"; };
    virtual string function2(){ return "Base - function2"; };
};

class Derived : public Base {
    virtual string function2(){ return "Derived - function2"; };
    virtual string function1(){ return "Derived - function1"; };
    string function3() { return "Derived - function3"; };
};

所以vtable结构是这样的

Base-vTable
-----------------------
name_of_function address_of_function
function1   &function1
function2   &function2
-----------------------
-----------------------
Derived-vTable
-----------------------
name_of_function address_of_function
function1   &function1
function2   &function2

或者是这样的

    Base-vTable
-----------------------
    Offset function
    +0  function1
    +4  function2
-----------------------
-----------------------
    Derived-vTable
-----------------------
    Offset function
    +0  function1
    +4  function2

如果是后者呢？那这个偏移量是多少？用在什么地方？

还有函数名： 它是错位的函数名称吗？如果它被损坏，则基本名称和派生的损坏名称将不匹配，并且 vtable 查找将不起作用。 编译器确实修改了所有的虚函数名称，所以它必须是一个修改过的名称，这是否意味着如果它是虚函数，则基数和派生的修改过的名称是相同的。

Answer 1

虚拟表只是函数指针的数组，就像您的第二个 sn-p 一样。编译器将对虚函数的调用转换为通过指针调用，例如

Base * b = /* ... */;
b->function2();

被翻译成

b->__vtable[1]();

我使用名称 __vtable 来指代虚拟表（但请注意，虚拟表通常不能直接访问）。

表中条目的顺序由函数在类中声明的顺序决定。请记住，类定义在调用点始终可用。

Answer 2

我正在解释以下代码。我想它会让你清楚

  Base *p = new Derived;
  p->function2();

在编译时，创建了VTable，Base类的VTable与Derived类的VTable相同。我的意思是两者都有你在第一种情况下提到的两个功能。编译器插入代码来初始化正确对象的 vptr。

当编译器看到语句 p->function2(); 时，它不会对被调用的函数做任何绑定，因为 t 只知道 Base 对象。从 Base 类的 VTable 可以知道 function2 的位置（这里是 VTable 中的第 2 个位置）。

在运行时，Dervied 类的 VTable 被分配给 vptr。调用 VTable 的第二个位置的函数。

Answer 3

清除此问题的最简单方法是查找实际实现。

考虑以下代码：

struct Base { virtual void foo() = 0; };

struct Derived { virtual void foo() { } };

Base& base();

void bar() {
  Base& b = base();
  b.foo();           // virtual call
}

现在，将其提供给 Clang 的 Try Out 页面以获取 LLVM IR：

; ModuleID = '/tmp/webcompile/_6336_0.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu"

%struct.Base = type { i32 (...)** }

define void @_Z3barv() {
  %1 = tail call %struct.Base* @_Z4basev()
  %2 = bitcast %struct.Base* %1 to void (%struct.Base*)***
  %3 = load void (%struct.Base*)*** %2, align 8
  %4 = load void (%struct.Base*)** %3, align 8
  tail call void %4(%struct.Base* %1)
  ret void
}

declare %struct.Base* @_Z4basev()

由于我想您可能还不了解 IR，所以让我们逐个回顾一下。

先来一些你不应该担心的东西。它标识了为其编译的架构（处理器和系统）及其属性。

; ModuleID = '/tmp/webcompile/_6336_0.bc'
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-unknown-linux-gnu"

然后，LLVM 会学习类型：

%struct.Base = type { i32 (...)** }

它从结构上分析类型。所以在这里我们只得到Base 将由单个元素i32 (...)** 组成：这实际上是“臭名昭著”的v-table 指针。为什么是这种奇怪的类型？因为我们会在v-table中存储很多不同类型的函数指针。这意味着我们将有一个异构数组（这是不可能的），因此我们将其视为“通用”未知元素的数组（以标记我们确保那里有什么），这取决于应用程序进行转换在实际使用它之前指向适当的函数指针类型的指针（或者更确切地说，如果我们在 C 或 C++ 中，IR 的级别要低得多）。

跳到最后：

declare %struct.Base* @_Z4basev()

这声明了一个函数（_Z4basev，名称被修改了），它返回一个指向Base的指针：在 IR 引用中，指针都由指针表示。

好的，让我们看看bar 的定义（或_Z3barv，因为它被破坏了）。这就是有趣的地方：

  %1 = tail call %struct.Base* @_Z4basev()

对base 的调用，它返回一个指向Base 的指针（返回类型总是在调用处精确，更容易分析），它存储在一个名为%1 的常量中。

  %2 = bitcast %struct.Base* %1 to void (%struct.Base*)***

一个奇怪的位广播，将我们的Base* 转换为一个指向奇怪事物的指针......本质上，我们正在获取 v-table 指针。它没有被“命名”，我们只是在类型的定义中确保它是第一个元素。

  %3 = load void (%struct.Base*)*** %2, align 8
  %4 = load void (%struct.Base*)** %3, align 8

我们首先加载 v-table（%2 指向），然后加载函数指针（%3 指向）。此时，%4 因此是&Derived::foo。

  tail call void %4(%struct.Base* %1)

最后，我们调用该函数，并将this 元素传递给它，这里明确。

Answer 4

第二种情况——假设指针占用 4 个字节（32 位机器）。

函数名称永远不会存储在可执行文件中（调试除外）。 虚拟表只是一个函数指针向量，运行代码直接访问。

Answer 5

这实际上取决于编译器，标准没有指定内存表示的工作方式。该标准规定多态性必须始终有效（即使在 inline 函数的情况下，就像你的一样）。您的函数可以内联，具体取决于编译器的上下文和智能性，因此有时call 或jmp 甚至可能不会出现。但是，在大多数编译器上，很可能会遇到第二种变体。

对于您的情况：

class Base{
    virtual string function1(){ return "Base - function1"; };
    virtual string function2(){ return "Base - function2"; };
};

class Derived : public Base {
    virtual string function2(){ return "Derived - function2"; };
    virtual string function1(){ return "Derived - function1"; };
};

假设你有：

Base* base = new Base;
Base* derived = new Derived;

base->function1();
derived->function2();

对于第一次调用，编译器将为Base 获取vftable 的地址并调用第一个函数，即vftable。对于第二次调用，vftable 位于不同的位置，因为该对象实际上是 Derived 类型。它搜索第二个函数，从遇到函数的 vftable 开头跳转到偏移量（意思是 vftable + offset - 很可能是 4 个字节，但同样取决于平台）。

Answer 6

当在类中添加虚函数时，编译器会创建一个隐藏指针（称为 v-ptr）作为该类的成员。[您可以通过 sizeof(class) 来检查它，它会增加 sizeof (pointer)] 编译器还在构造函数的开头添加了一些代码，以将 v-ptr 初始化为类的 v-table 的基本偏移量。现在，当这个类由某个其他类派生时，这个 v-ptr 也由 Derived 类派生。对于 Derived 类，这个 v-ptr 被初始化为 Derived 类的 v-table 的基本偏移量。而且我们已经知道，各个类的 v-tables 将存储它们的虚函数版本的地址。 [请注意，如果派生类中没有重写虚函数，则层次结构中函数的基版本或大多数派生版本（用于多级继承）的地址将存储在 v-table 中]。因此在运行时它只是通过这个 v-ptr 调用函数。因此，如果基类指针存储了一个基对象，那么 v-ptr 的基版本就会起作用。由于它指向 v-table 的基本版本，因此将自动调用函数的基本版本。 Derived 对象也是如此。