0

我试图在我的 C 程序中获取 FP，我尝试了两种不同的方法，但它们都与我运行 GDB 时得到的不同。

我尝试的第一种方法是，我在 C 中为 Assembly 函数制作了一个协议函数：

int* getEbp();

我的代码如下所示：

int* ebp = getEbp(); 
printf("ebp: %08x\n", ebp); // value i get here is 0xbfe2db58

while( esp <= ebp )       
    esp -= 4;

printf( "ebp: %08x, esp" ); //value i get here is 0xbfe2daec

我的汇编代码

getEbp:
    movl %ebp, %eax
    ret

我尝试让原型函数只返回一个 int，但这也与我的 GDB 输出不匹配。我们正在使用 x86 程序集。

编辑：错别字，我的 getEsp 函数看起来和另一个函数一模一样：

getEsp:
    movl %esp, %eax
    ret
4

2 回答 2

6
  1. 对于读取寄存器，确实最好使用GCC 扩展的内联汇编语法。
  2. 如果您在单独的汇编程序文件中编译它，您getEbp()看起来应该可以工作。
  3. 您getEsp()显然是不正确的，因为它没有考虑调用者推送的返回地址。

这是一个代码片段，它ebp通过扩展的内联 asm 并通过追逐帧指针来展开堆栈：

struct stack_frame {
        struct stack_frame *prev;
        void *return_addr;
} __attribute__((packed));
typedef struct stack_frame stack_frame;

void backtrace_from_fp(void **buf, int size)
{
        int i;
        stack_frame *fp;

        __asm__("movl %%ebp, %[fp]" :  /* output */ [fp] "=r" (fp));

        for(i = 0; i < size && fp != NULL; fp = fp->prev, i++)
                buf[i] = fp->return_addr;
}

我将在下面展示两种读取寄存器的工作实现。纯 asm 函数是get_ebp()和get_esp()in getbp.S。get_esp_inline()作为内联函数实现的另一组get_ebp_inline()位于test-getbp.c.

在getbp.S

.section .text
/* obviously incurring the cost of a function call
   to read a register is inefficient */
.global get_ebp
get_ebp:
movl %ebp, %eax
ret

.global get_esp
get_esp:
/* 4: return address pushed by caller */
lea 4(%esp), %eax
ret

在test-getbp.c

#include <stdio.h>
#include <stdint.h>

/* see http://sourceware.org/systemtap/wiki/UserSpaceProbeImplementation */
#include <sys/sdt.h>

int32_t *get_ebp(void);
int32_t *get_esp(void);

__attribute__((always_inline)) uintptr_t *get_ebp_inline(void)
{
    uintptr_t *r;
    __asm__ volatile ("movl %%ebp, %[r]" : /* output */ [r] "=r" (r));
    return r;
}

__attribute__((always_inline)) uintptr_t *get_esp_inline(void)
{
    uintptr_t *r;
    __asm__ volatile ("movl %%esp, %[r]" : /* output */ [r] "=r" (r));
    return r;
}

int main(int argc, char **argv)
{
    uintptr_t *bp, *sp;

    /* allocate some random data on the stack just for fun */
    int a[10] = { 1, 3, 4, 9 };
    fprintf(fopen("/dev/null", "r"), "%d\n", a[3]);

    STAP_PROBE(getbp, getbp); /* a static probe is like a named breakpoint */
    bp = get_ebp();
    sp = get_esp();
    printf("asm: %p, %p\n", (void*)bp, (void*)sp);
    bp = get_ebp_inline();
    sp = get_esp_inline();
    printf("inline: %p, %p\n", (void*)bp, (void*)sp);
    return 0;
}

我们现在可以编写一个 GDB 脚本来进行转储ebp，esp同时使用上面getbp定义的静态探针test-getbp.c。

在test-getbp.gdb

file test-getbp

set breakpoint pending on
break -p getbp
commands
silent
printf "gdb: 0x%04x, 0x%04x\n", $ebp, $esp
continue
end

run
quit

要验证这些函数是否返回与 GDB 相同的数据：

$ gdb -x test-getbp.gdb
< ... >
gdb: 0xffffc938, 0xffffc920
asm: 0xffffc938, 0xffffc920
inline: 0xffffc938, 0xffffc920
< ... >

拆解test-getbp main()产生：

   0x08048370 <+0>: push   %ebp
   0x08048371 <+1>: mov    %esp,%ebp
   0x08048373 <+3>: push   %ebx
   0x08048374 <+4>: and    $0xfffffff0,%esp
   0x08048377 <+7>: sub    $0x10,%esp
   0x0804837a <+10>:    movl   $0x8048584,0x4(%esp)
   0x08048382 <+18>:    movl   $0x8048586,(%esp)
   0x08048389 <+25>:    call   0x8048360 <fopen@plt>
   0x0804838e <+30>:    movl   $0x9,0x8(%esp)
   0x08048396 <+38>:    movl   $0x8048590,0x4(%esp)
   0x0804839e <+46>:    mov    %eax,(%esp)
   0x080483a1 <+49>:    call   0x8048350 <fprintf@plt>
   0x080483a6 <+54>:    nop
   0x080483a7 <+55>:    call   0x80484e4 <get_ebp>
   0x080483ac <+60>:    mov    %eax,%ebx
   0x080483ae <+62>:    call   0x80484e7 <get_esp>
   0x080483b3 <+67>:    mov    %ebx,0x4(%esp)
   0x080483b7 <+71>:    movl   $0x8048594,(%esp)
   0x080483be <+78>:    mov    %eax,0x8(%esp)
   0x080483c2 <+82>:    call   0x8048320 <printf@plt>
   0x080483c7 <+87>:    mov    %ebp,%eax
   0x080483c9 <+89>:    mov    %esp,%edx
   0x080483cb <+91>:    mov    %edx,0x8(%esp)
   0x080483cf <+95>:    mov    %eax,0x4(%esp)
   0x080483d3 <+99>:    movl   $0x80485a1,(%esp)
   0x080483da <+106>:   call   0x8048320 <printf@plt>
   0x080483df <+111>:   xor    %eax,%eax
   0x080483e1 <+113>:   mov    -0x4(%ebp),%ebx
   0x080483e4 <+116>:   leave  
   0x080483e5 <+117>:   ret

nopat<main+54>是静态探针。printf有关如何读取寄存器的信息，请参阅两个调用周围的代码。

顺便说一句，你代码中的这个循环对我来说似乎很奇怪：

while( esp <= ebp )       
    esp -= 4;

你不是说

while (esp < ebp)
    esp +=4

?

于 2012-11-18T08:25:01.277 回答
4

因为您依赖于实现特定的细节，所以您需要提供有关您的目标的更多信息以获得准确的答案。您没有指定回答您的问题真正需要的架构、编译器或操作系统。

根据您引用的寄存器名称和您使用 at&t 语法的事实进行有根据的猜测，我将假设这是 i386 并且您使用的是 gcc。

实现这一点最简单的方法是使用 gcc 变量属性，你可以试试这个，这是一个 gcc 特定的语法来请求特定的寄存器。

#include <stdint.h>
#include <stdio.h>

int main(int argc, char **argv)
{
     const uintptr_t register framep asm("ebp");

     fprintf(stderr, "val: %#x\n", framep);

     return 0;
 }

另一种方法是使用内联汇编来加载值，如下所示：

#include <stdint.h>
#include <stdio.h>

int main(int argc, char **argv)
{
    uintptr_t framep;

    asm("movl %%ebp, %0" : "=r" (framep));

    fprintf(stderr, "val: %#x\n", framep);

    return 0;
}

这会请求一个 32 位寄存器用于写入操作（= 修饰符），并将其加载到 framep。编译器负责提取您声明的值。

在 gdb 中，您可以打印该值并验证它是否与输出匹配。

(gdb) b main
Breakpoint 1 at 0x40117f: file ebp2.c, line 8.
(gdb) r
Starting program: /home/zero/a.exe
[New Thread 4664.0x1290]
[New Thread 4664.0x13c4]

Breakpoint 1, main (argc=1, argv=0x28ac50) at ebp2.c:8
8           asm("movl %%ebp, %0" : "=r" (framep));
(gdb) n
10          fprintf(stderr, "val: %#x\n", framep);
(gdb) p/x framep
$1 = 0x28ac28
(gdb) p/x $ebp
$2 = 0x28ac28
(gdb) c
Continuing.
val: 0x28ac28
[Inferior 1 (process 4664) exited normally]
(gdb) q

请记住，您不能依赖此行为，即使在 x86 gcc 上也可以配置为不使用帧指针并手动跟踪堆栈使用情况。这通常被微软称为 FPO，或者在其他平台上称为 omit-frame-pointer。这个技巧为通用用途释放了另一个寄存器，但使调试更加复杂。

您是正确的，eax 通常在 x86 调用约定中尽可能用于返回值，我不知道为什么您的帖子上的评论声称使用了堆栈。

于 2012-11-18T04:53:38.170 回答