造成这种情况的原因主要有两个：停机问题是半可判定的（即，有时我们可以解决它），而c++ 标准允许 llvm 作弊并假装它解决了停机问题，即使它没有

如何解决停机问题

（注意：本节内容有些牵强；我稍后可能会使其更加严格，但我认为它本身就提供了很好的直觉）

停机问题表明我们永远无法制作一个程序，它接受另一个程序并说“是，这停止”或“不，它不停止”。但我们实际上并不需要这样的东西。相反，我们想要的是一个程序，它接受另一个程序并说“是，这停止”或“不，它不停止”或“这太复杂了；我不知道”。这很容易实现（您可以一直说“不知道”），但我们希望有一些策略来提供更有用的结果。以下是一种行之有效的特定策略

如果我们可以确定一个归纳数据类型的实例，其值在每次循环迭代中都会减少，那么我们就可以确保循环终止。为什么？因为最终，归纳数据类型将“触底”。在那时，没有办法进一步减少它。但为了继续进行下一次循环迭代，我们必须减少它。这意味着我们不能继续进行下一次循环迭代；无论是在那时还是在那之前，我们都必须终止循环

这里的减少量在哪里？首先将“int”换成“unsigned”；整数可以归纳定义，但顺序会变得混乱，这会让事情变得更加混乱，而且这里本来就没有负数。自然数更容易处理，数值顺序可以满足我们的需要。现在，每次迭代减少的数量是 n*n – k。在任何给定的迭代中，它要么是零，要么是非零。如果 n*n – k == 0，则 n*n == k，因此循环终止。否则，我们继续进行下一次循环迭代，k 增加 1，因此 n*n – k 减少 1

值得再次强调归纳类型在这里所起的作用。在不可变语言中，链表是归纳的，因此对链表的迭代总会终止。另一方面，在可变语言（如 c）中，对链表的迭代不一定会终止，因为列表中可能有循环

如何欺骗标准化人员为您解决停机问题

请参阅中的 intro.progress 部分。这实际上表明，编译器可以简单地假设你所展示的循环总是会终止，如果你编写了一个不会终止的循环，那是你自己的错

Clang 既没有解决停机问题，也没有永远评估循环。它只是在编译过程中优化了一次循环。

让我们像优化编译器一样编译代码

这里混合了各种优化，因此请尽量使其变得非常简单。

首先，square(int n)用 调用n = 10。这很重要，因为10是一个常量，所以编译器现在可以为这个特定的调用创建此函数的副本。这称为，也是 鼓励的inline。特化函数现在是：

inline int square_10()    // Const parameter removed
{
    int k = 0;
    while ( true )
    {
        if( k == 10*10 )  // Const value replaced
            return k;
        k++;
    }
};

这里，10*10被简单优化为100。剩下的代码不多了（这在后面很重要）。

有一个k初始化为 0 的局部变量，还有一个while(true)循环，只有两个语句。一个是if，另一个是 的局部增量k。从后者开始，编译器可以将 的范围推断为k所有正数（直到达到未定义的行为）。

内部编译的代码现在在内存中大致表示为：

inline int square_10()
{
    // k = $ALL_POSITIVE_INT (compiler internal state)
    while ( true )
        if( k == 100 )
            return k;
};

这也可以通过两个步骤轻松优化。首先，if最终将为真，因为100在范围内k，因此return可以达到。当return达到时，k被限制为100。

没有其他指令会改变结果，因此该代码唯一可能的效果被优化为：

inline int square_10()
{
    return 100;
}

没有对 的调用square(int n)，因此永远不会生成“正常”函数。代码现在简化为返回常量的内联函数。它被内联为：

int main()
{
    return 100;
}

好吧，这很好，但是让我们测试一下上面的一些假设。

常数参数和乘法消元

您可以尝试用原始示例中的 ，您将看到编译器不再将代码优化为常量。10getchar()

它将消除循环，但保留mul，因为现在函数结果实际上取决于函数参数：返回仅对于常量参数是常量。

范围检查和循环消除

您可以进一步 k++，k = getchar()您将看到编译器不会消除循环（如跳转、je和 所观察到的jne）。

它还将保持在imul左右，因为编译器不能假设任何k超出初始零的值。

优化编译器只关心会产生影响的代码

putchar(0);在 内的任何位置插入while都会禁用循环消除。putchar(0);在 之前插入 会while产生一些额外的汇编，而putchar(0);在 之后插入 则while不会产生任何效果，因为它被上述相同的优化检测为死代码。

TL：DR；

函数特化、常量传播、常量折叠、范围检查、代码不变分析和死代码消除的混合可以生成这些结果。无需评估。

这里有很多关于归纳类型和内联的讨论，但是代码中的优化可以通过更简单的方法实现。

让我们看看这个函数

inline int square( int n )
{
    int k = 0;
    while ( true )
    {
        if( k == n*n )
            return k;
        
        k++;
    }
};

它只有一种返回方式 – 如果k == n*n。如果为真，它将返回k，因此编译器可以将代码转换为返回n*n– 这是一个更简单的表达式，因为它在循环期间是恒定的（与 不同k）

inline int square( int n )
{
    int k = 0;
    while ( true )
    {
        if( k == n*n )
            return n*n; //  <-- !!
        
        k++;
    }
};

现在，编译器处于不同的场景中。它知道它将返回什么值，但不知道它是否会返回。幸运的是，它可以假设这一点！当有一个“简单”*循环时，它永远运行是未定义的行为。现在编译器有两个关键事实：

• 循环返回n*n，从函数开始就保持不变，n从未改变
• 循环必须返回**

因此，可以简单地将函数改为

inline int square( int n )
{
    return n*n;
}

现在，如果无限循环不被视为未定义，它必须证明循环总是终止。它可以使用之前讨论过的归纳逻辑相当简单地做到这一点：

• n*n必须始终为正，并且处于int
• k从零开始并增加到 int 的整个正值范围
• 因此，k在某一点必须相等n*n
• 通过这种稍微复杂的逻辑，它可以进行与之前相同的转换

获取程序集的最后一步是最终内联此函数并使用提供的常量值，但这并不重要:)

* “简单”意味着不做任何外界可见的事情，比如 IO 或易失性访问。

** 出于清晰的考虑，C 编译器通常不会以这种方式优化循环，因为如果无限循环消失，就会造成混淆。它的真实逻辑可能更接近于第二个循环优化，但以第一种方式进行优化仍然完全合法

这不是问题的答案，因为它与 Clang 无关，但我们还在，并且还支持断言过程始终终止的指令。

除了编译时求值之外，它对于目标重新排序也很有用。在纯声明性语言中，这种转换几乎总是正确的：

p(), q() -> q(), p()

（即“调用p然后调用q”可以重新排序）。唯一不正确的情况是如果调用q可以无限循环。

当然，还有其他情况需要考虑；比如，也许p和q都可能引发异常。但如果您正在设计语言，您可以简单地认为在这种情况下引发任一异常都是有效的语义。

语言规范可以通过两种方式让编译器避免解决停机问题，从而实现原本简单而有用的优化：

1. 语言规范可能允许将操作推迟到可以观察到其副作用为止，并且如果永远不会观察到其副作用，则将操作永远推迟（实际上完全跳过），并且指定代码段内的分支具有单个出口，该出口可从该段内的所有代码静态到达，而不必将其本身视为副作用。

2. 语言规范可能会指定，如果程序收到的输入会导致其陷入无副作用的无限循环，则实现可能会以任意方式运行。

前一种方法将允许后者实现的大多数有用的优化，但允许人类或自动代码验证器推断程序不变量。后一种方法如果不证明程序将对所有可能的输入终止，则无法证明任何不变量，但允许编译器同时应用两种优化，从而避免做出艰难的决定，即是否省略循环或利用在循环存在时建立的后置条件。

恕我直言，第二种方法对于大多数类型的任务来说都是适得其反的，因为编译器能够提高正确代码性能的唯一情况是：

1. 程序员可以证明程序会在所有可能的输入下终止，但编译器却不能。

2. 不需要程序维护内存安全或任何其他可能导致程序陷入无限循环的输入不变量。

如果程序包含任何有副作用的循环，而这些循环有可能无法终止，那么确保不变量得到遵守的唯一方法就是在循环中添加虚拟副作用或添加人为的退出条件，这两种情况都意味着，即使循环是无用的，编译器也不允许省略循环，或者编译器省略循环的权利不取决于无限循环是否具有定义的行为。

因此，虽然第一种语义方法下允许的优化可以在正确的程序中有效地使用，但更广泛的语义下允许的优化主要在处理错误程序时有效。