objdump of binary with debug info produces mangled output

Question

I often notice severely mangled output with mixed assembly and C instructions in the output of objdump -S. This seems to happen only for binaries built with debug info. Is there any way to fix this?

To illustrate the issue i have written a simple program :

/* test.c */
#include <stdio.h>
int main()
{
        static int i = 0;    
        while(i < 0x1000000) {
                i++;
        }
        return 0;
}

The above program was built with/without debug info as follows :

$ gcc test.c -o test-release
$ gcc test.c -g -o test-debug

Disassembling the test-release binary works fine.
$ objdump -S test-release
produces the following clear and concise snippet for the main() function.

 080483b4 <main>:
 80483b4:       55                      push   %ebp
 80483b5:       89 e5                   mov    %esp,%ebp
 80483b7:       eb 0d                   jmp    80483c6 <main+0x12>
 80483b9:       a1 18 a0 04 08          mov    0x804a018,%eax
 80483be:       83 c0 01                add    $0x1,%eax
 80483c1:       a3 18 a0 04 08          mov    %eax,0x804a018
 80483c6:       a1 18 a0 04 08          mov    0x804a018,%eax
 80483cb:       3d ff ff ff 00          cmp    $0xffffff,%eax
 80483d0:       7e e7                   jle    80483b9 <main+0x5>
 80483d2:       b8 00 00 00 00          mov    $0x0,%eax
 80483d7:       5d                      pop    %ebp
 80483d8:       c3                      ret 

But $ objdump -S test-debug
produces the following mangled snippet for the same main() function.

080483b4 <main>:
#include <stdio.h>

int main()
{
 80483b4:       55                      push   %ebp
 80483b5:       89 e5                   mov    %esp,%ebp

        static int i = 0;

        while(i < 0x1000000) {
 80483b7:       eb 0d                   jmp    80483c6 <main+0x12>
                i++;
 80483b9:       a1 18 a0 04 08          mov    0x804a018,%eax
 80483be:       83 c0 01                add    $0x1,%eax
 80483c1:       a3 18 a0 04 08          mov    %eax,0x804a018
int main()
{

        static int i = 0;

        while(i < 0x1000000) {
 80483c6:       a1 18 a0 04 08          mov    0x804a018,%eax
 80483cb:       3d ff ff ff 00          cmp    $0xffffff,%eax
 80483d0:       7e e7                   jle    80483b9 <main+0x5>
                i++;
        }   

        return 0;
 80483d2:       b8 00 00 00 00          mov    $0x0,%eax

}
 80483d7:       5d                      pop    %ebp
 80483d8:       c3                      ret

I do understand that as the debug binary contains additional symbol info, the C code is displayed interlaced with the assembly instructions. But this makes it a tad difficult to follow the flow of code.

Is there any way to instruct objdump to output pure assembly and not interlace debug symbols into the output even if encountered in a binary?

Answer 1

Use -d instead of -S. objdump is doing exactly what you are telling it to. The -S option implies -d but also displays the C source if debugging information is available.