CODEWITHSUNDEEP
assemblyterminalgdbatt
MichaelGofron
MichaelGofron

Reputation: 1410

What is the jmpq command doing in this example

We are using gdb debugger to read assembly functions.

In assembly, we have the following instructions: mov 0xc(%rsp),%eax jmpq *0x402390(,%rax,8)

At memory location *0x402390 we have the value 0x8e. In register rax, we have the second integer input for this particular function (could use variable y).

From our analysis, we have deduced that this function takes in three variables (x, y, z) and that they can be found at memory location (rsp), (rsp + 8), (rsp + 12) respectively.

We would like to know what is going on in jmpq *0x402390(,%rax,8). Is it jumping to the instruction at (0x8e + rax*8)? If so, how can we find out what that instruction is called?

This is the full dump of assembler code for the function phase_3:

Full assembly function

Upvotes: 15

Views: 65385

Answers (3)

Celsius_Xu
Celsius_Xu

Reputation: 381

Bomb-lab right lol?

This operation jmpq *0x402390(,%rax,8) is for jumping directly to the absolute address stored at
8 * %rax + 0x402390

If you do x/16gx 0x402390 in gdb (inspect 16 "giant words" in hexadecimal starting at 0x402390) you will find an address table looks like the following:(i have a different lab so it's not the same as yours)

 0x402880:  0x0000000000400fee  0x000000000040102b
 0x402890:  0x0000000000400ff5  0x0000000000400ffc
 0x4028a0:  0x0000000000401003  0x000000000040100a
 0x4028b0:  0x0000000000401011  0x0000000000401018

Where all these addresses all point back to the a single mov operation immediately after jmpq *0x402390(,%rax,8)

Upvotes: 24

rkhb
rkhb

Reputation: 14409

From the GAS-manual:

An Intel syntax indirect memory reference of the form

 section:[base + index*scale + disp]

is translated into the AT&T syntax

 section:disp(base, index, scale)

where base and index are the optional 32-bit base and index registers, disp is the optional displacement, and scale, taking the values 1, 2, 4, and 8, multiplies index to calculate the address of the operand.

(https://sourceware.org/binutils/docs/as/i386_002dMemory.html#i386_002dMemory)

So you can translate jmpq *0x402390(,%rax,8) into INTEL-syntax: jmp [RAX*8 + 0x402390]. It's an "indirect" jump. At address [RAX*8 + 0x402390] is an address which will become the target of jmp. The next step is to determine, how many addresses can be found at 0x402390 + x and in which case they are used.

Upvotes: 16

rcgldr
rcgldr

Reputation: 28826

It's jumping into a table of code that has 8 bytes per entry, sort of like a switch case statement optimization. It's a bit confusing because there is a series of 7 byte sequences just after the jmpq, and the code that the jmpq branches to (starting at 402390) is not shown in the image.

Upvotes: 1

Related Questions