作为遗留代码库更新工具链的一部分，我们希望从 Borland C++ 5.02 编译器转移到 Microsoft 编译器(VS2008 或更高版本)。这是一个嵌入式环境，其中堆栈地址空间是预定义的并且相当有限。事实证明，我们有一个带有大量 switch 语句的函数，这会导致在 MS 编译器下比在 Borland 下分配更大的堆栈分配，实际上会导致堆栈溢出。

代码的形式是这样的:

#ifdef PKTS
#define RETURN_TYPE SPacket

typedef struct
{
   int a;
   int b;
   int c;
   int d;
   int e;
   int f;
} SPacket;

SPacket error = {0,0,0,0,0,0};
#else
#define RETURN_TYPE int

int error = 0;
#endif

extern RETURN_TYPE pickone(int key);

void findresult(int key, RETURN_TYPE* result)
{
   switch(key)
   {
      case 1   : *result = pickone(5 ); break;
      case 2   : *result = pickone(6 ); break;
      case 3   : *result = pickone(7 ); break;
      case 4   : *result = pickone(8 ); break;
      case 5   : *result = pickone(9 ); break;
      case 6   : *result = pickone(10); break;
      case 7   : *result = pickone(11); break;
      case 8   : *result = pickone(12); break;
      case 9   : *result = pickone(13); break;
      case 10  : *result = pickone(14); break;
      case 11  : *result = pickone(15); break;
      default  : *result = error;       break;
   }
}

当使用 cl/O2/FAs/c/DPKTS stack_alloc.cpp 编译时，列表文件的一部分如下所示:

_TEXT   SEGMENT
$T2592 = -264                       ; size = 24
$T2582 = -240                       ; size = 24
$T2594 = -216                       ; size = 24
$T2586 = -192                       ; size = 24
$T2596 = -168                       ; size = 24
$T2590 = -144                       ; size = 24
$T2598 = -120                       ; size = 24
$T2588 = -96                        ; size = 24
$T2600 = -72                        ; size = 24
$T2584 = -48                        ; size = 24
$T2602 = -24                        ; size = 24
_key$ = 8                       ; size = 4
_result$ = 12                       ; size = 4
?findresult@@YAXHPAUSPacket@@@Z PROC            ; findresult, COMDAT

; 27   :    switch(key)

    mov eax, DWORD PTR _key$[esp-4]
    dec eax
    sub esp, 264                ; 00000108H
...

$LN11@findresult:

; 30   :       case 2   : *result = pickone(6 ); break;

    push    6
    lea ecx, DWORD PTR $T2584[esp+268]
    push    ecx
    jmp SHORT $LN17@findresult
$LN10@findresult:

; 31   :       case 3   : *result = pickone(7 ); break;

    push    7
    lea ecx, DWORD PTR $T2586[esp+268]
    push    ecx
    jmp SHORT $LN17@findresult

$LN17@findresult:
    call    ?pickone@@YA?AUSPacket@@H@Z     ; pickone
    mov edx, DWORD PTR [eax]
    mov ecx, DWORD PTR _result$[esp+268]
    mov DWORD PTR [ecx], edx
    mov edx, DWORD PTR [eax+4]
    mov DWORD PTR [ecx+4], edx
    mov edx, DWORD PTR [eax+8]
    mov DWORD PTR [ecx+8], edx
    mov edx, DWORD PTR [eax+12]
    mov DWORD PTR [ecx+12], edx
    mov edx, DWORD PTR [eax+16]
    mov DWORD PTR [ecx+16], edx
    mov eax, DWORD PTR [eax+20]
    add esp, 8
    mov DWORD PTR [ecx+20], eax

; 41   :    }
; 42   : }

    add esp, 264                ; 00000108H
    ret 0

分配的堆栈空间包括用于每种情况的专用位置，用于临时存储从pickone() 返回的结构，尽管最终只会将一个值复制到result 结构。正如您可以想象的那样，随着此函数中更大的结构、更多的案例和递归调用，可用堆栈空间会被迅速消耗。

如果返回类型是 POD，当上面没有 /DPKTS 指令编译时，每个 case 直接复制到 result，堆栈使用效率更高:

$LN10@findresult:

; 31   :       case 3   : *result = pickone(7 ); break;

    push    7
    call    ?pickone@@YAHH@Z            ; pickone
    mov ecx, DWORD PTR _result$[esp]
    add esp, 4
    mov DWORD PTR [ecx], eax

; 41   :    }
; 42   : }

    ret 0

谁能解释为什么编译器采用这种方法，是否有办法说服它采用其他方法？我重新设计代码的自由有限，因此 pragma 等是更理想的解决方案。到目前为止，我还没有发现优化、调试等参数的任何组合会有所作为。

谢谢!

编辑

我理解findresult()需要为pickone()的返回值分配空间。我不明白的是，为什么编译器会为开关中的每种可能情况分配额外的空间。似乎一个临时空间就足够了。事实上，这就是 gcc 处理相同代码的方式。另一方面，Borland 似乎使用 RVO，将指针一直向下传递并避免使用临时指针。 MS C++ 编译器是三种编译器中唯一为开关中的每种情况保留空间的编译器。

我知道当您不知道测试代码的哪些部分可以更改时，很难提出重构选项的建议——这就是为什么我的第一个问题是为什么编译器以这种方式运行在测试用例中。我希望，如果我能理解这一点，我可以选择最佳的重构/编译指示/命令行选项来修复它。

最佳答案

为什么不只是

void findresult(int key, RETURN_TYPE* result)
{
   if (key >= 1 && key <= 11)
     *result = pickone(4+key);
   else
     *result = error;
}

假设这算是一个较小的变化，我只记得一个关于范围的老问题，特别是与嵌入式编译器有关。如果将每个案例用大括号括起来以显式限制临时范围，优化器会做得更好吗？

switch(key)
{
   case 1   : { *result = pickone(5 ); break; }

另一个改变范围的选项:

void findresult(int key, RETURN_TYPE* result)
{
    RETURN_TYPE tmp;
    switch(key)
    {
      case 1   : tmp = pickone(5 ); break;
      ...
    }
    *result = tmp;
}

这有点手忙脚乱，因为我们只是想猜测哪个输入会促使这个不幸的优化器做出明智的响应。

关于c++ - 如何防止 MSVC++ 为 switch 语句过度分配堆栈空间？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14162465/