How to deal with single line wrapped into multiple lines in gdb? - c

Question

For example,
int main()
{
int aa = 1, bb =2, cc = 3;
int dd = ( (aa + 3 - 1)
/ bb)
<< cc;
printf("%d\n", dd);
return 1;
}
So I break int dd line to multiple lines just to demonstrate.
Then I use gdb to debug.
Breakpoint 1, main () at a.c:25
25 int aa = 1, bb =2, cc = 3;
(gdb) n
26 int dd = ( (aa + 3 - 1)
(gdb) n
27 / bb)
(gdb) n
26 int dd = ( (aa + 3 - 1)
(gdb) n
29 printf("%d\n", dd);
(gdb) n
8
30 return 1;
As you can see int dd shown multiple times and << cc does not show.
How to avoid this? For example when I type n and enter, gdb show the complete int dd line once, and when I type n again, gdb goes to next line?

Answer 1

There is nothing you can do from within GDB because it merely follows the debugging information produced by the compiler. You can see the assembly output with gcc -g -S -fverbose-asm -fno-dwarf2-cfi-asm -o - main.c. Thanks to the annotations you should be able to get the gist of it even if you don't know assembly.
Here is an excerpt:
# main.c:4: int dd = ( (aa + 3 - 1)
movl -4(%rbp), %eax # aa, tmp91
addl $2, %eax #, _1
# main.c:5: / bb)
cltd
idivl -8(%rbp) # bb
movl %eax, %edx # tmp92, _2
# main.c:4: int dd = ( (aa + 3 - 1)
movl -12(%rbp), %eax # cc, tmp94
movl %eax, %ecx # tmp94, tmp99
sall %cl, %edx # tmp99, _2
movl %edx, %eax # _2, tmp95
movl %eax, -16(%rbp) # tmp95, dd
The last block is equivalent to
int dd = _2 << cc;
Since the result of an operation has to be stored somewhere the shift and assignment are not split. The reference is to the line containing the assignment.
You should rewrite the code to have one operation per statement:
int t1 = (aa + 3 - 1);
int t2 = t1 / bb;
int dd = t2 << cc;
Here is the corresponding assembly:
# main.c:4: int t1 = (aa + 3 - 1);
movl -4(%rbp), %eax # aa, tmp92
addl $2, %eax #, tmp91
movl %eax, -16(%rbp) # tmp91, t1
# main.c:5: int t2 = t1 / bb;
movl -16(%rbp), %eax # t1, tmp96
cltd
idivl -8(%rbp) # bb
movl %eax, -20(%rbp) # tmp94, t2
# main.c:6: int dd = t2 << cc;
movl -12(%rbp), %eax # cc, tmp100
movl -20(%rbp), %edx # t2, tmp102
movl %eax, %ecx # tmp100, tmp106
sall %cl, %edx # tmp106, tmp102
movl %edx, %eax # tmp102, tmp101
movl %eax, -24(%rbp) # tmp101, dd
It is essentially the same as before but now the blocks match the statements perfectly. You can't control the compiler's output but it will try to preserve the boundaries between statements, so that is your best option.