Assembly showing a lot of repeating code?

Question

So I'm working on some binary to assembly to c++ code. It's for a project.

When I disassemble the binary I'm getting a lot of repeating assembly code and I'm not sure what it's doing. It's almost like it's just pointing it's way down.

   0x0000000000000000 <+0>:     push   %rbp
   0x0000000000000001 <+1>:     mov    %rsp,%rbp
   0x0000000000000004 <+4>:     lea    0x0(%rip),%rsi        # 0xb <main+11>
   0x000000000000000b <+11>:    lea    0x0(%rip),%rdi        # 0x12 <main+18>
   0x0000000000000012 <+18>:    callq  0x17 <main+23>
   0x0000000000000017 <+23>:    callq  0x1c <main+28>
   0x000000000000001c <+28>:    mov    %eax,0x0(%rip)        # 0x22 <main+34>
   0x0000000000000022 <+34>:    mov    0x0(%rip),%eax        # 0x28 <main+40>
   0x0000000000000028 <+40>:    cmp    $0x1,%eax
   0x000000000000002b <+43>:    je     0x40 <main+64>
   0x000000000000002d <+45>:    lea    0x0(%rip),%rsi        # 0x34 <main+52>
   0x0000000000000034 <+52>:    lea    0x0(%rip),%rdi        # 0x3b <main+59>
   0x000000000000003b <+59>:    callq  0x40 <main+64>
   0x0000000000000040 <+64>:    mov    0x0(%rip),%eax        # 0x46 <main+70>
   0x0000000000000046 <+70>:    cmp    $0x1,%eax

So the repeating code is the "lea" and "callq". Based on the way I'm reading it, it's just pointing to the next line down. For example, the first lea ends with #0xb <main+11> which is the line right below it, and that one points to the line below it, and so on. Can anyone help with what I'm looking at?

There's at least a hundred extra lines in the project, so I'm not looking for a free A, I just need help understanding.

Edit: I am working with a .o file without access to the original .cpp file and the task is to use GDB and Bless to help me read the Assembly output and reassemble it into a .cpp file that works the same as the original code.

Answer 1

So the repeating code is the "lea" and "callq".

The addresses suggest that you are disassembling .o file, not an executable (you should always show the command you used when asking about its output).

Try objdump -dr foo.o instead -- the picture should become much clearer.

P.S. GDB isn't really the right tool for looking at .o files anyway.

Update:

I tried the objdump -dr Project1.o and got pretty much the same output

Look closer: it's not the same output. objdump will display relocations, which show where he CALL will actually go to.

You should also be able to link Project1.o into an executable (something like gcc Project1.o -o Project1), and run gdb Project1 and then disas main. You will see that that disassembly makes more sense, and also matches the output of objdump.