堆栈一般是用来保存变量之类的东西（静态变量在内存中，虽然堆栈就是内存的一部分，但为了防止歧义，还是分成两部分来说），一般情况下没必要去故意读取堆栈的值，变量用变量名就可以直接访问，但我曾经想要读取函数返回后代码继续执行的地址，因此想到了来读取堆栈（函数调用时，会向堆栈中压入参数和下一个代码执行的地址，这样就可以在函数返回后继续执行）。
先来测试一下我们能否读取堆栈：
#include<stdio.h>
int main()
{
volatile int a=24;/*设置一个我们要读取的变量,volatile 可以告诉gcc不要优化这行代码，仅对变量有效*/
volatile int b[2]={1,2};/*建立一个数组，这个数组是关键，这时b作为数组指针，指向第一个元素，即
1在堆栈中的储存位置，因此我们就可以利用b来读取堆栈的任意位置（该程序所拥有的堆栈）*/
volatile int c=b[2];
printf("%d\n",c);//打印出指定位置堆栈的值
return 0;
}
当然，如果不设定编译器的参数，这样的代码可能是不会编译通过的（注意：可能），命令如下：
gcc -Wno-unused -m32 -S -O0 -o test.s test.c
源文件名为test.c，参数说明：
-Wno-unused：不警告未使用的变量（上面的程序不需要，但为了方便自己分析，放在这里）
-m32：编译为32位程序
-S：编译为汇编文件
-O0：优化等级为0
-o：重命名输出文件
现在让我们看看汇编文件是什么样的：
.file "test.c"
.def ___main; .scl 2; .type 32; .endef
.section .rdata,"dr"
LC0:
.ascii "%d\12\0"
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
LFB10:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
pushl %esi
pushl %ebx
andl $-16, %esp
subl $32, %esp
.cfi_offset 6, -12
.cfi_offset 3, -16
call ___main
movl $24, 28(%esp) //将24存入堆栈，位置是28+esp的值
movl $1, %ebx //1存入ebx
movl $2, %esi //2存入esi
movl %ebx, 20(%esp) //1存入20(%esp)
movl %esi, 24(%esp) //2存入24(%esp)
movl 28(%esp), %eax //将28(%esp)的值存入eax，这里对应的代码就是c=b[2],即将24存入了eax
movl %eax, 16(%esp) //剩下的就是将参数压入堆栈，然后调用printf，这里不再解释
movl 16(%esp), %eax
movl %eax, 4(%esp)
movl $LC0, (%esp)
call _printf
movl $0, %eax
leal -8(%ebp), %esp
popl %ebx
.cfi_restore 3
popl %esi
.cfi_restore 6
popl %ebp
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE10:
.ident "GCC: (MinGW.org GCC-6.3.0-1) 6.3.0"
.def _printf; .scl 2; .type 32; .endef
通过汇编的内容，我们可以看出可以使用一个数组来访问有效堆栈内的全部内容（超出堆栈界限会引发错误）。输出结果如下：
当调用一个函数时（使用call指令），压入参数的同时会压下一个代码的地址，使函数返回后可以继续执行。现在来尝试获取这个地址，代码如下：
#include<stdio.h>
void fun()
{
volatile int a[1];/*设置一个数组，使用这个数组来访问堆栈*/
a[0]=14;
printf("a[4]=%d\n",a[4]);/*打印出call指令压入的地址，这里很有意思，我之前以为这个地址在
a[2],a[0]=14，a[1]是esp的值（C语言中所有函数的开头都会有push ebp的代码，将ebp的值保存进堆栈，然后
将esp保存进ebp），但实际上发现总会有两个不知名的值占据着a[2],a[3]的位置，具体可以参见汇编代码*/
goto *(a[4]);/*使用goto语句可以让程序跳向任何合法地址，goto不仅可以用标号或者行号，还可以是任
何void*型的变量（前提是程序可以访问该地址），goto会被程序翻译为jmp指令，而(*(void(*)
(void))0x100000)();这样的跳转方式将会被翻译为call指令，会使堆栈中多出一个地址，具体要使用哪个需要
参考实际。*/
}
int main()
{
fun();
printf("hello");/*理论上如果上面的goto生效，那么hello将会被执行两次（调用fun函数时，堆栈被压入该
地址，然后使用了goto后，跳转到这里执行一次，打印出一个hello，在下面的return 0;语句中，程序会认为当
前还在fun函数，毕竟堆栈中的地址还没有释放，因此重新返回到这里，再执行一次），否则由于地址错误，程
序将被迫退出，不会在控制台看到hello*/
return 0;
}
下面是实际执行的情况，可见我们确实得到了之前压入的那个地址：
以下是上面的那个程序的汇编程序：
.file "test.c"
.section .rdata,"dr"
LC0:
.ascii "a[4]=%d\12\0"
.text
.globl _fun
.def _fun; .scl 2; .type 32; .endef
_fun:
LFB10:
.cfi_startproc
pushl %ebp //将ebp的值送入堆栈
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
subl $40, %esp //空出40字节的位置用来储存变量
movl $14, -12(%ebp) //14存入a[0]，所以a的值即是ebp偏移12个字节，
//可以推断出a[1]在-8(%ebp),a[2]在-4(%ebp),a[3]在0(%esp),所以a[3]是之前保存的ebp的值
//那么a[4]就是call指令保存的值，这里比较令人好奇为什么a[0]在-12(%ebp)
movl 4(%ebp), %eax
movl %eax, 4(%esp)
movl $LC0, (%esp)
call _printf
movl 4(%ebp), %eax
jmp *%eax //goto被翻译为jmp指令，然后跳向了我们指定的地址
.cfi_endproc
LFE10:
.def ___main; .scl 2; .type 32; .endef
.section .rdata,"dr"
LC1:
.ascii "hello\0"
.text
.globl _main
.def _main; .scl 2; .type 32; .endef
_main:
LFB11:
.cfi_startproc
pushl %ebp
.cfi_def_cfa_offset 8
.cfi_offset 5, -8
movl %esp, %ebp
.cfi_def_cfa_register 5
andl $-16, %esp
subl $16, %esp
call ___main
call _fun
movl $LC1, (%esp)
call _printf
movl $0, %eax
leave
.cfi_restore 5
.cfi_def_cfa 4, 4
ret
.cfi_endproc
LFE11:
.ident "GCC: (MinGW.org GCC-6.3.0-1) 6.3.0"
.def _printf; .scl 2; .type 32; .endef
所以这里验证了我们可以通过操作数组来读取堆栈。