2

假设这个 C 代码：

int main(){
    int n;
    scanf("%d\n", &n);

    int a[n];
    int i;
    
    for (i = 0; i<n; i++){
        a[i] = 1;
    }

}

我们有一个在堆栈空间中的向量，但是直到执行时间（直到用户给变量 n 赋值）我们才知道向量的大小。所以我的问题是：何时以及如何为堆栈部分中的该向量保留空间？

直到现在我才明白堆栈空间是在编译时保留的，而堆空间是在运行时保留的（使用 malloc 之类的函数）。但是直到运行时我们才能知道这个向量的大小。

我认为可以做的是在知道它的那一刻从堆栈指针中减去 n 的值，从而扩大该函数的堆栈以使向量适合（我提到的这种减法只能在汇编代码）。

但是我一直在做一些测试来观察 /proc/[pid]/maps 的内容。并且进程的堆栈空间没有改变，所以我认为（在汇编代码中将 n*sizeof(int) 减去堆栈顶部的指令）没有完成。我在 main 函数的开头和结尾都看过 /proc/[pid]/maps 的内容。

如果我为 x86 (gcc -m32 -o test.c) 汇编这段代码，你会得到以下汇编代码（以备不时之需）：

.file   "test.c"
    .text
    .section    .rodata
.LC0:
    .string "%d\n"
    .text
    .globl  main
    .type   main, @function
main:
.LFB0:
    .cfi_startproc
    leal    4(%esp), %ecx
    .cfi_def_cfa 1, 0
    andl    $-16, %esp
    pushl   -4(%ecx)
    pushl   %ebp
    .cfi_escape 0x10,0x5,0x2,0x75,0
    movl    %esp, %ebp
    pushl   %esi
    pushl   %ebx
    pushl   %ecx
    .cfi_escape 0xf,0x3,0x75,0x74,0x6
    .cfi_escape 0x10,0x6,0x2,0x75,0x7c
    .cfi_escape 0x10,0x3,0x2,0x75,0x78
    subl    $44, %esp
    call    __x86.get_pc_thunk.ax
    addl    $_GLOBAL_OFFSET_TABLE_, %eax
    movl    %gs:20, %ecx
    movl    %ecx, -28(%ebp)
    xorl    %ecx, %ecx
    movl    %esp, %edx
    movl    %edx, %esi
    subl    $8, %esp
    leal    -44(%ebp), %edx
    pushl   %edx
    leal    .LC0@GOTOFF(%eax), %edx
    pushl   %edx
    movl    %eax, %ebx
    call    __isoc99_scanf@PLT
    addl    $16, %esp
    movl    -44(%ebp), %eax
    leal    -1(%eax), %edx
    movl    %edx, -36(%ebp)
    sall    $2, %eax
    leal    3(%eax), %edx
    movl    $16, %eax
    subl    $1, %eax
    addl    %edx, %eax
    movl    $16, %ebx
    movl    $0, %edx
    divl    %ebx
    imull   $16, %eax, %eax
    subl    %eax, %esp
    movl    %esp, %eax
    addl    $3, %eax
    shrl    $2, %eax
    sall    $2, %eax
    movl    %eax, -32(%ebp)
    movl    $0, -40(%ebp)
    jmp .L2
.L3:
    movl    -32(%ebp), %eax
    movl    -40(%ebp), %edx
    movl    $1, (%eax,%edx,4)
    addl    $1, -40(%ebp)
.L2:
    movl    -44(%ebp), %eax
    cmpl    %eax, -40(%ebp)
    jl  .L3
    movl    %esi, %esp
    movl    $0, %eax
    movl    -28(%ebp), %ecx
    xorl    %gs:20, %ecx
    je  .L5
    call    __stack_chk_fail_local
.L5:
    leal    -12(%ebp), %esp
    popl    %ecx
    .cfi_restore 1
    .cfi_def_cfa 1, 0
    popl    %ebx
    .cfi_restore 3
    popl    %esi
    .cfi_restore 6
    popl    %ebp
    .cfi_restore 5
    leal    -4(%ecx), %esp
    .cfi_def_cfa 4, 4
    ret
    .cfi_endproc
.LFE0:
    .size   main, .-main
    .section    .text.__x86.get_pc_thunk.ax,"axG",@progbits,__x86.get_pc_thunk.ax,comdat
    .globl  __x86.get_pc_thunk.ax
    .hidden __x86.get_pc_thunk.ax
    .type   __x86.get_pc_thunk.ax, @function
__x86.get_pc_thunk.ax:
.LFB1:
    .cfi_startproc
    movl    (%esp), %eax
    ret
    .cfi_endproc
.LFE1:
    .hidden __stack_chk_fail_local
    .ident  "GCC: (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0"
    .section    .note.GNU-stack,"",@progbits
4

3 回答 3

0

这是特定于平台的，但通常会在程序启动时保留空间，并且您有最大堆栈大小。在 Windows 上，根据 Microsoft的默认最大值为 1MB ，您可以使用链接器设置（在 Visual Studio 的项目属性中）更改它。

如果你的程序是多线程的，其他线程的堆栈空间在启动时会被保留。

如果您尝试使用比实际更多的堆栈空间，那么通常情况下，您的程序会崩溃，并且它可能也可能不是安全漏洞（即让人们侵入您的程序） - 请参阅“堆栈冲突”。

于 2020-06-30T15:42:39.540 回答
0

您可以阅读有关该问题的评论，感谢 PeterCordes 的帮助，这些评论已经解决了我的问题。基本上会发生的是，堆栈中需要数组的空间将在运行时在数组声明的精确时刻保留（因为此时 n 是一个已知值）。我们将在汇编代码中有一条指令，即 stackPointer = stackPointer - n * sizeof(int)。

于 2020-07-01T22:33:27.797 回答
0

首先，您的代码严重损坏：直到n用于设置. 之后更改不会更改数组维度。可变长度数组是 C99 的一项特性，C99 消除了将声明放在块中任何其他语句之前的需要，使您可以在语句为该大小的数组保留堆栈空间之前进入。int vector[n];nscanfn int vector[n];

直到现在我才明白堆栈空间是在编译时保留的，而堆空间是在运行时保留的

总堆栈区域在程序启动时保留。根据操作系统，为堆栈增长保留的空间量由操作系统设置选择，而不是可执行文件中的元数据。（例如在 Linux 中，通过ulimit -s设置初始线程的堆栈，而 pthreads 选择为每个线程堆栈分配多少空间。）

堆栈帧的布局在编译时是固定的（局部变量相对于彼此的位置），但每次函数运行时都会发生实际分配。这就是函数可以递归和可重入的方式！这也是使堆栈成为堆栈的原因：在最后为当前函数腾出空间，在返回之前立即释放它。（可变长度数组并alloca具有运行时可变大小，因此编译器通常会将它们放在其他局部变量之下。）

只有静态存储在编译时真正保留/分配。（全局和static变量。）

（ISO C不需要实际的堆栈，只需要自动存储变量生命周期的 LIFO 语义。一些 ISA 上的一些实现基本上动态地为堆栈帧分配空间，例如使用 malloc，而不是使用堆栈。）

这排除了在编译时为局部变量静态分配空间。在大多数 C 实现中，它们都在 x86-64sub rsp, 24或其他的堆栈上。当然，局部变量相对于彼此的布局在编译时是固定的，在大分配内部，因此编译器不需要编写存储指向对象指针的代码，它们只需发出使用寻址模式的指令，如[rsp + 4].

所以我的问题是：何时以及如何为堆栈部分中的该向量保留空间？

逻辑上在 C 抽象机中：当到达int vector[n]语句时，在这个函数的执行中。 相比之下，固定大小的对象存在于封闭范围的顶部。

因此，您的示例被严重破坏。在分配 VLA之前，您保持n未初始化！编译您的代码并启用警告以捕获此类问题。 应该是之前。（另外，不要将普通数组称为“向量”，这对于了解 C++ 的人来说是错误的。）scanfint vector[n]

但是在这种情况下，C 和 x86 中提到局部变量应该按照声明顺序放置的规则将不被遵守。

没有这样的规则。在 ISO C 中，甚至写入vector < &n和比较单独对象的地址都是未定义的行为。（C++ 允许使用std::less; C 没有等效项 C 是否具有与 C++ 中的 std::less 等效项？）。

AC 编译器可以根据自己的选择来布置其堆栈帧，例如将小对象组合在一起以避免在填充上浪费空间来对齐更大的对齐对象。

x86 asm 根本没有变量声明。作为程序员（或 C 编译器），您可以编写移动堆栈指针的指令，并使用内存寻址模式访问您想要访问的内存。通常，您会以实现“变量”的高级概念的方式执行此操作。

例如，让我们制作一个n以函数 arg 为参数的函数版本，而不是使用 scanf。

#include <stdio.h>

void use_mem(void*);   // compiler can't optimize away calls to this unknown function

void foo(int size) {
    int n = size;  // uninitialized was UB
    int array[n];
    int i;
    i = 5;     // optimizes away, i is kept in a register

    //scanf("%d\n", &n);  // read some different size later???  makes no sense
    for (i = 0; i<n; i++){
        array[i] = 1;
    }
    use_mem(array);  // make the stores not be dead
}

在带有 GCC10.1 -O2 -Wall的 Godbolt 上，对于 x86-64 System V：

foo(int):
        push    rbp
        movsx   rax, edi             # sign-extend n
        lea     rax, [15+rax*4]      # round size up
        and     rax, -16             # to a multiple of 16, to main stack alignment
        mov     rbp, rsp            # finish setting up a frame pointer
        sub     rsp, rax             # allocate space for array[]
        mov     r8, rsp              # keep a pointer to it
        test    edi, edi             # if ( n==0 ) skip the loop
        jle     .L2
        mov     edi, edi             # zero-extend n
        mov     rax, r8              # int *p = array
        lea     rdx, [r8+rdi*4]      # endp = &array[(unsigned)n]
.L3:                                 # do{
        mov     DWORD PTR [rax], 1     # *p = 1
        add     rax, 4                 # pointer increment
        cmp     rax, rdx
        jne     .L3                  # }while(p != endp)
.L2:
        mov     rdi, r8             # pass a pointer to the VLA
        call    use_mem(void*)
        leave                       # tear down frame pointer / stack frame
        ret

请注意，call use_mem运行时，array[n]空间位于堆栈指针上方，即“已分配”。

如果use_mem回调到这个函数中，另一个具有自己大小的 VLA 实例将被分配到堆栈上。

该leave指令只是mov rsp, rbp/ pop rbp，因此它将堆栈指针设置为指向已分配空间的上方，并取消分配它。

于 2020-10-13T03:04:57.887 回答