生产编译器如何在流控制上实现析构函数处理

Question

长话短说 - 我正在编写一个编译器，并在达到 OOP 功能时遇到了涉及处理析构函数的两难境地。 基本上我有两个选择：

• 1 - 将所有需要在该点调用的对象的析构函数放在程序中。 这个选项听起来像性能友好和简单，但会膨胀代码，因为根据控制流，某些析构函数可以重复多次。

• 2 - 为每个带有标签的代码块划分析构函数，并仅通过那些需要的“spaghetti jump”。 优点 - 不会重复析构函数，缺点 - 将涉及非顺序执行和跳转，以及额外的隐藏变量和条件，例如确定执行是否离开块以继续在父级中执行阻止或中断/继续/转到/返回，这也增加了其复杂性。 额外的变量和检查很可能会占用这种方法节省的空间，具体取决于对象的数量以及内部结构和控制流的复杂程度。

我知道对这些问题的通常回答是“两者都做，分析和决定”，如果这是一项微不足道的任务，这就是我会做的事情，但事实证明，编写一个功能齐全的编译器有些艰巨，所以我更愿意获得一些专家的意见而不是比建两座桥，看哪一座做得更好，然后烧掉另一座。

我将 c++ 放在标签中，因为这是我使用的语言，并且对它和 RAII 范式有点熟悉，这也是我的编译器正在建模的内容。

Answer 1

大多数情况下，析构函数调用的处理方式与普通函数调用的处理方式相同。

较小的部分是处理 EH。 我注意到 MSC 在“普通”代码中生成内联析构函数调用的混合，并且对于 x86-64，创建单独的清理代码，其本身可能包含或不包含析构函数逻辑的副本。

IMO，最简单的解决方案是始终将非平凡的析构函数称为普通函数。

如果优化似乎即将到来，请将上述调用视为其他任何事情：它是否适合与其他所有内容一起放入缓存中？ 这样做会占用图像中的太多空间吗？ 等等..

前端可以在其输出 AST 中每个可操作块的末尾插入对非平凡析构函数的“调用”。

后端可以将诸如普通函数调用之类的事情处理，将它们连接在一起，在某处创建一个大的块-o-析构函数调用逻辑并跳转到那个，等等......

将函数链接到相同的逻辑似乎很常见。 例如，MSC 倾向于将所有琐碎的功能链接到相同的实现、析构函数或其他方式，优化与否。

这主要来自经验。 像往常一样，YMMV。

还有一件事：

EH 清理逻辑倾向于像跳转表一样工作：对于给定的函数，您可以只跳转到单个析构函数调用列表，具体取决于抛出异常的位置（如果适用）。

Answer 2

我不知道商业编译器是如何产生代码的，但假设我们此时忽略异常 [1]，我将采取的方法是调用析构函数，而不是内联它。 每个析构函数都包含该对象的完整析构函数。 使用循环来处理数组的析构函数。

内联调用是一种优化，除非您“知道它有回报”（代码大小与速度），否则您不应该这样做。

您将需要处理“封闭块中的破坏”，但假设您没有跳出块，那应该很容易。 跳出块（例如 return、break 等）意味着您必须跳转到一段代码来清理您所在的块。

[1] 商业编译器具有基于“抛出异常的位置”的特殊表，以及生成的一段代码来进行清理 - 通常通过在每个清理块中具有多个跳转标签来为许多异常点重用相同的清理。

Answer 3

编译器混合使用这两种方法。 MSVC 使用内联析构函数调用正常代码流并以相反的顺序清理代码块以实现早期返回和异常。 在正常流程中，它使用单个隐藏的局部整数来跟踪迄今为止的构造函数进度，因此它知道在早期返回时跳到哪里。 单个整数就足够了，因为作用域总是形成一棵树（而不是说对每个已成功或未成功构造的类使用位掩码）。 例如，以下相当短的代码使用一个带有非平凡析构函数的类和一些随机返回的类......

    ...
    if (randomBool()) return;
    Foo a;
    if (randomBool()) return;
    Foo b;
    if (randomBool()) return;

    {
        Foo c;
        if (randomBool()) return;
    }

    {
        Foo d;
        if (randomBool()) return;
    }
    ...

...可以在 x86 上扩展为如下伪代码，其中构造函数进度在每次构造函数调用后立即增加（有时比下一个唯一值增加一个以上）并在每次调用之前减少（或“弹出”到较早的值）析构函数调用。 请注意，具有简单析构函数的类不会影响此值。

    ...
    save previous exception handler // for x86, not 64-bit table based handling
    preallocate stack space for locals
    set new exception handler address to ExceptionCleanup
    set constructor progress = 0
    if randomBool(), goto Cleanup0
    Foo a;
    set constructor progress = 1 // Advance 1
    if randomBool(), goto Cleanup1
    Foo b;
    set constructor progress = 2 // And once more
    if randomBool(), goto Cleanup2

    {
        Foo c;
        set constructor progress = 3
        if randomBool(), goto Cleanup3
        set constructor progress = 2 // Pop to 2 again
        c.~Foo();
    }

    {
        Foo d;
        set constructor progress = 4 // Increment 2 to 4, not 3 again
        if randomBool(), goto Cleanup4
        set constructor progress = 2 // Pop to 2 again
        d.~Foo();
    }

// alternate Cleanup2
    set constructor progress = 1
    b.~Foo();
// alternate Cleanup1
    set constructor progress = 0
    a.~Foo();

Cleanup0:
    restore previous exception handler
    wipe stack space for locals
    return;

ExceptionCleanup:
    switch (constructor progress)
    {
    case 0: goto Cleanup0; // nothing to destroy
    case 1: goto Cleanup1;
    case 2: goto Cleanup2;
    case 3: goto Cleanup3;
    case 4: goto Cleanup4;
    }
    // admitting ignorance here, as I don't know how the exception
    // is propagated upward, and whether the exact same cleanup
    // blocks are shared for both early returns and exceptions.

Cleanup4:
    set constructor progress = 2
    d.~Foo();
    goto Cleanup2;
Cleanup3:
    set constructor progress = 2
    c.~Foo();
    // fall through to Cleanup2;
Cleanup2:
    set constructor progress = 1
    b.~Foo();
Cleanup1:
    set constructor progress = 0
    a.~Foo();
    goto Cleanup0;
    // or it may instead return directly here

编译器当然可以以任何它认为更有效的方式重新排列这些块，而不是将所有清理工作放在最后。 提前返回可能会跳转到函数末尾的备用 Cleanup1/2。 在 64 位 MSVC 代码上，异常是通过将异常发生时的指令指针映射到相应代码清理块的表来处理的。

Answer 4

优化编译器正在转换已编译源代码的内部表示。

它通常构建基本块的有向（通常是循环）图。 在构建此控制流图时，它会添加对析构函数的调用。

对于GCC （它是一个免费软件编译器 - Clang/LLVM也是如此 - 所以你可以研究它的源代码），你可能可以尝试使用-fdump-tree-all编译一些简单的 C++ 测试用例代码，然后看到它是在gimplification时间完成的。 顺便说一句，您可以使用MELT自定义g++以探索其内部表示。

顺便说一句，我不认为你如何处理析构函数那么重要（注意，在 C++ 中，它们在语法定义的地方被隐式调用，比如它们定义范围的} ）。 这种编译器的大部分工作都在优化（那么，处理析构函数不是很相关；它们几乎是像其他程序一样的例程）。