<值优化输出>在gdb中是什么意思?


77
(gdb) n
134   a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
(gdb) n
(gdb) p a
$30 = <value optimized out>
(gdb) p b
$31 = <value optimized out>
(gdb) p c
$32 = 3735928563

gdb如何优化我的价值?



a,b和c是指针吗?
Darshan L

Answers:


74

这意味着您使用eg进行编译,gcc -O3并且gcc优化器发现某些变量在某种程度上是多余的,从而使它们得以优化。在这种特殊情况下,您似乎拥有三个具有相同值的变量a,b,c,并且可以将它们全部别名为一个变量。例如gcc -O0,如果您想查看此类变量,则在禁用优化的情况下进行编译(在任何情况下,这通常都是调试构建的一个好主意)。


1
但是这里a不是多余的,以后需要使用177 case 3 : a+=k[0]&0xffffff; break;
。– gdb

3
如果要进一步分析,则需要发布所有相关代码。
Paul R

1
优化器将尽可能在寄存器中保留临时变量。如果它们都具有相同的值,它也可以将多个变量别名给同一个寄存器,直到其中一个变量被修改为止,然后可以将其分配给不同的寄存器。因此,优化代码中变量的生存期可能与源代码中显示的不同。如果您不想对这种行为感到困惑,请关闭优化。
Paul R

2
较新的gcc具有一个选项,-Og它仅应用那些不会损害可调试性的优化-非常有用(也man gcc适用于-gdwarf4)。另外,如果您不想对其进行编译器优化,但又不想为整个构建禁用优化,则可以将不想丢失的变量临时定义volatile为!这两个信息都来自这里:ask.xmodulo.com/print-optimized-out-value-gdb.html
kavadias,

3
@kavadias,该-Og选项可能正是导致变量被优化的问题!在这里查看我的答案:stackoverflow.com/a/63386263/4561887。因此,如果您遇到任何错误,说<optimized out>Can't take address of "var" which isn't an lvalue.,则必须使用-O0 而不是 -Og
加布里埃尔·斯台普斯

6

带有分解分析的最小可运行示例

像往常一样,我希望看到一些分解,以更好地了解正在发生的事情。

在这种情况下,我们获得的见解是,如果将变量优化为仅存储在寄存器中而不是堆栈中,然后将其所在的寄存器覆盖,则<optimized out>R.所述

当然,只有在不再需要有关变量的情况下,这种情况才会发生,否则程序将失去其值。因此,在函数开始时您可以看到变量值,但在结束时它变为,这往往会发生<optimized out>

我们经常对此感兴趣的一种典型情况是函数参数本身,因为它们是:

  • 始终在函数开始时定义
  • 由于计算出更多的中间值,可能无法在函数末尾使用。
  • 往往会被进一步的功能子调用覆盖,这些子调用必须设置完全相同的寄存器以满足调用约定

这种理解实际上有一个具体的应用:使用反向调试时,您可以简单地通过退回到它们的最后一个使用点来恢复感兴趣的变量的值:如何查看变量的<optimized out> C ++?

main.c

#include <stdio.h>

int __attribute__((noinline)) f3(int i) {
    return i + 1;
}

int __attribute__((noinline)) f2(int i) {
    return f3(i) + 1;
}

int __attribute__((noinline)) f1(int i) {
    int j = 1, k = 2, l = 3;
    i += 1;
    j += f2(i);
    k += f2(j);
    l += f2(k);
    return l;
}

int main(int argc, char *argv[]) {
    printf("%d\n", f1(argc));
    return 0;
}

编译并运行:

gcc -ggdb3 -O3 -std=c99 -Wall -Wextra -pedantic -o main.out main.c
gdb -q -nh main.out

然后在GDB中,我们进行以下会话:

Breakpoint 1, f1 (i=1) at main.c:13
13          i += 1;
(gdb) disas
Dump of assembler code for function f1:
=> 0x00005555555546c0 <+0>:     add    $0x1,%edi
   0x00005555555546c3 <+3>:     callq  0x5555555546b0 <f2>
   0x00005555555546c8 <+8>:     lea    0x1(%rax),%edi
   0x00005555555546cb <+11>:    callq  0x5555555546b0 <f2>
   0x00005555555546d0 <+16>:    lea    0x2(%rax),%edi
   0x00005555555546d3 <+19>:    callq  0x5555555546b0 <f2>
   0x00005555555546d8 <+24>:    add    $0x3,%eax
   0x00005555555546db <+27>:    retq   
End of assembler dump.
(gdb) p i
$1 = 1
(gdb) p j
$2 = 1
(gdb) n
14          j += f2(i);
(gdb) disas
Dump of assembler code for function f1:
   0x00005555555546c0 <+0>:     add    $0x1,%edi
=> 0x00005555555546c3 <+3>:     callq  0x5555555546b0 <f2>
   0x00005555555546c8 <+8>:     lea    0x1(%rax),%edi
   0x00005555555546cb <+11>:    callq  0x5555555546b0 <f2>
   0x00005555555546d0 <+16>:    lea    0x2(%rax),%edi
   0x00005555555546d3 <+19>:    callq  0x5555555546b0 <f2>
   0x00005555555546d8 <+24>:    add    $0x3,%eax
   0x00005555555546db <+27>:    retq   
End of assembler dump.
(gdb) p i
$3 = 2
(gdb) p j
$4 = 1
(gdb) n
15          k += f2(j);
(gdb) disas
Dump of assembler code for function f1:
   0x00005555555546c0 <+0>:     add    $0x1,%edi
   0x00005555555546c3 <+3>:     callq  0x5555555546b0 <f2>
   0x00005555555546c8 <+8>:     lea    0x1(%rax),%edi
=> 0x00005555555546cb <+11>:    callq  0x5555555546b0 <f2>
   0x00005555555546d0 <+16>:    lea    0x2(%rax),%edi
   0x00005555555546d3 <+19>:    callq  0x5555555546b0 <f2>
   0x00005555555546d8 <+24>:    add    $0x3,%eax
   0x00005555555546db <+27>:    retq   
End of assembler dump.
(gdb) p i
$5 = <optimized out>
(gdb) p j
$6 = 5
(gdb) n
16          l += f2(k);
(gdb) disas
Dump of assembler code for function f1:
   0x00005555555546c0 <+0>:     add    $0x1,%edi
   0x00005555555546c3 <+3>:     callq  0x5555555546b0 <f2>
   0x00005555555546c8 <+8>:     lea    0x1(%rax),%edi
   0x00005555555546cb <+11>:    callq  0x5555555546b0 <f2>
   0x00005555555546d0 <+16>:    lea    0x2(%rax),%edi
=> 0x00005555555546d3 <+19>:    callq  0x5555555546b0 <f2>
   0x00005555555546d8 <+24>:    add    $0x3,%eax
   0x00005555555546db <+27>:    retq   
End of assembler dump.
(gdb) p i
$7 = <optimized out>
(gdb) p j
$8 = <optimized out>

要了解发生了什么,请记住x86 Linux调用约定:i386和x86-64上UNIX和Linux系统调用的调用约定是什么,您应该知道:

  • RDI包含第一个参数
  • RDI可能在函数调用中被破坏
  • RAX包含返回值

由此我们可以得出:

add    $0x1,%edi

对应于:

i += 1;

因为i是的第一个参数f1,所以存储在RDI中。

现在,当我们都在:

i += 1;
j += f2(i);

RDI的值没有被修改,因此GDB可以随时在这些行中查询它。

但是,一旦f2拨打电话:

  • i程序中不再需要的值
  • lea 0x1(%rax),%ediEDI = j + RAX + 1这样做:
    • 初始化 j = 1
    • 设置下一个f2调用的第一个参数RDI = j

因此,当到达以下行时:

k += f2(j);

以下两个指令都已经/可能已经修改了RDI,这是唯一i被存储的位置(f2可以将其用作暂存器,并且lea绝对将其设置为RAX + 1):

   0x00005555555546c3 <+3>:     callq  0x5555555546b0 <f2>
   0x00005555555546c8 <+8>:     lea    0x1(%rax),%edi

因此RDI不再包含值i。实际上,的价值i已完全丧失!因此,唯一可能的结果是:

$3 = <optimized out>

的值也会发生类似的变化j,尽管j在调用以后只需要一行就不再需要了k += f2(j);

思考j还使我们对GDB的智能程度有了一些了解。值得注意的是,在i += 1;的值j尚未在任何寄存器或内存地址中实现,并且GDB必须仅基于调试信息元数据知道它。

-O0 分析

如果我们使用-O0而不是-O3进行编译:

gcc -ggdb3 -O0 -std=c99 -Wall -Wextra -pedantic -o main.out main.c

然后反汇编看起来像:

11      int __attribute__((noinline)) f1(int i) {
=> 0x0000555555554673 <+0>:     55      push   %rbp
   0x0000555555554674 <+1>:     48 89 e5        mov    %rsp,%rbp
   0x0000555555554677 <+4>:     48 83 ec 18     sub    $0x18,%rsp
   0x000055555555467b <+8>:     89 7d ec        mov    %edi,-0x14(%rbp)

12          int j = 1, k = 2, l = 3;
   0x000055555555467e <+11>:    c7 45 f4 01 00 00 00    movl   $0x1,-0xc(%rbp)
   0x0000555555554685 <+18>:    c7 45 f8 02 00 00 00    movl   $0x2,-0x8(%rbp)
   0x000055555555468c <+25>:    c7 45 fc 03 00 00 00    movl   $0x3,-0x4(%rbp)

13          i += 1;
   0x0000555555554693 <+32>:    83 45 ec 01     addl   $0x1,-0x14(%rbp)

14          j += f2(i);
   0x0000555555554697 <+36>:    8b 45 ec        mov    -0x14(%rbp),%eax
   0x000055555555469a <+39>:    89 c7   mov    %eax,%edi
   0x000055555555469c <+41>:    e8 b8 ff ff ff  callq  0x555555554659 <f2>
   0x00005555555546a1 <+46>:    01 45 f4        add    %eax,-0xc(%rbp)

15          k += f2(j);
   0x00005555555546a4 <+49>:    8b 45 f4        mov    -0xc(%rbp),%eax
   0x00005555555546a7 <+52>:    89 c7   mov    %eax,%edi
   0x00005555555546a9 <+54>:    e8 ab ff ff ff  callq  0x555555554659 <f2>
   0x00005555555546ae <+59>:    01 45 f8        add    %eax,-0x8(%rbp)

16          l += f2(k);
   0x00005555555546b1 <+62>:    8b 45 f8        mov    -0x8(%rbp),%eax
   0x00005555555546b4 <+65>:    89 c7   mov    %eax,%edi
   0x00005555555546b6 <+67>:    e8 9e ff ff ff  callq  0x555555554659 <f2>
   0x00005555555546bb <+72>:    01 45 fc        add    %eax,-0x4(%rbp)

17          return l;
   0x00005555555546be <+75>:    8b 45 fc        mov    -0x4(%rbp),%eax

18      }
   0x00005555555546c1 <+78>:    c9      leaveq 
   0x00005555555546c2 <+79>:    c3      retq 

从这种可怕的反汇编中,我们看到RDI的值在程序执行的最开始就被移到了堆栈:

mov    %edi,-0x14(%rbp)

然后在需要时将其从内存中检索到寄存器中,例如:

14          j += f2(i);
   0x0000555555554697 <+36>:    8b 45 ec        mov    -0x14(%rbp),%eax
   0x000055555555469a <+39>:    89 c7   mov    %eax,%edi
   0x000055555555469c <+41>:    e8 b8 ff ff ff  callq  0x555555554659 <f2>
   0x00005555555546a1 <+46>:    01 45 f4        add    %eax,-0xc(%rbp)

j初始化后,立即将其压入堆栈的情况基本相同:

   0x000055555555467e <+11>:    c7 45 f4 01 00 00 00    movl   $0x1,-0xc(%rbp)

因此,GDB可以随时轻松找到这些变量的值:它们始终存在于内存中!

这也使我们对为什么无法避免<optimized out>在优化的代码中有了一些见解:由于寄存器的数量是有限的,因此唯一的方法是将不需要的寄存器实际推入内存,这将部分抵消的好处-O3

延长使用寿命 i

如果我们编辑f1返回l + i如下:

int __attribute__((noinline)) f1(int i) {
    int j = 1, k = 2, l = 3;
    i += 1;
    j += f2(i);
    k += f2(j);
    l += f2(k);
    return l + i;
}

然后我们观察到,这有效地扩展了功能的可见性,i直到函数结束。

这是因为这样,我们迫使GCC使用额外的变量来保留i到最后:

   0x00005555555546c0 <+0>:     lea    0x1(%rdi),%edx
   0x00005555555546c3 <+3>:     mov    %edx,%edi
   0x00005555555546c5 <+5>:     callq  0x5555555546b0 <f2>
   0x00005555555546ca <+10>:    lea    0x1(%rax),%edi
   0x00005555555546cd <+13>:    callq  0x5555555546b0 <f2>
   0x00005555555546d2 <+18>:    lea    0x2(%rax),%edi
   0x00005555555546d5 <+21>:    callq  0x5555555546b0 <f2>
   0x00005555555546da <+26>:    lea    0x3(%rdx,%rax,1),%eax
   0x00005555555546de <+30>:    retq

编译器通过i += i在第一条指令中存储在RDX中来完成此操作。

在Ubuntu 18.04,GCC 7.4.0,GDB 8.1.0中进行了测试。


5

没有。您的编译器做了,但是原始变量名仍然有一个调试符号。



1

您需要关闭编译器优化。

如果您对gdb中的特定变量感兴趣,可以将变量删除为“ volatile”并重新编译代码。这将使编译器关闭该变量的编译器优化。

volatile int数量= 0;


-1

只需运行“ export COPTS ='-g -O0';”即可。并重建您的代码。重建后,使用gdb对其进行调试。您不会看到这样的错误。谢谢。


AFAICTCOPTS并非正在gcc接受的环境变量(假设gcc正在使用)。
sappjw

不要忘了附加$COPTS到您的编译命令。
Akib Azmain
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.