(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如何优化我的价值?
Answers:
这意味着您使用eg进行编译,gcc -O3
并且gcc优化器发现某些变量在某种程度上是多余的,从而使它们得以优化。在这种特殊情况下,您似乎拥有三个具有相同值的变量a,b,c,并且可以将它们全部别名为一个变量。例如gcc -O0
,如果您想查看此类变量,则在禁用优化的情况下进行编译(在任何情况下,这通常都是调试构建的一个好主意)。
a
不是多余的,以后需要使用177 case 3 : a+=k[0]&0xffffff; break;
-Og
它仅应用那些不会损害可调试性的优化-非常有用(也man gcc
适用于-gdwarf4
)。另外,如果您不想对其进行编译器优化,但又不想为整个构建禁用优化,则可以将不想丢失的变量临时定义volatile
为!这两个信息都来自这里:ask.xmodulo.com/print-optimized-out-value-gdb.html
-Og
选项可能正是导致变量被优化的问题!在这里查看我的答案:stackoverflow.com/a/63386263/4561887。因此,如果您遇到任何错误,说<optimized out>
或Can't take address of "var" which isn't an lvalue.
,则必须使用-O0
而不是 -Og
!
带有分解分析的最小可运行示例
像往常一样,我希望看到一些分解,以更好地了解正在发生的事情。
在这种情况下,我们获得的见解是,如果将变量优化为仅存储在寄存器中而不是堆栈中,然后将其所在的寄存器覆盖,则<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系统调用的调用约定是什么,您应该知道:
由此我们可以得出:
add $0x1,%edi
对应于:
i += 1;
因为i
是的第一个参数f1
,所以存储在RDI中。
现在,当我们都在:
i += 1;
j += f2(i);
RDI的值没有被修改,因此GDB可以随时在这些行中查询它。
但是,一旦f2
拨打电话:
i
程序中不再需要的值lea 0x1(%rax),%edi
都EDI = 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中进行了测试。
来自https://idlebox.net/2010/apidocs/gdb-7.0.zip/gdb_9.html
未保存在其堆栈框架中的参数的值显示为“值优化输出”。
我想你是用-O(somevalue)编译的,并且正在发生优化的函数中访问变量a,b,c。
只需运行“ export COPTS ='-g -O0';”即可。并重建您的代码。重建后,使用gdb对其进行调试。您不会看到这样的错误。谢谢。
COPTS
并非正在gcc
接受的环境变量(假设gcc
正在使用)。
$COPTS
到您的编译命令。