Question

1. Understanding assembly language:

The assembly language for cars() is:

(gdb) disass cars

Dump of assembler code for function vanilla:

   0x00000000004004cd <+0>:     push   %rbp

   0x00000000004004ce <+1>:     mov    %rsp,%rbp

   0x00000000004004d1 <+4>:     mov    %edi,-0x14(%rbp)

   0x00000000004004d4 <+7>:     mov    -0x14(%rbp),%eax

   0x00000000004004d7 <+10>:    add    %eax,%eax

   0x00000000004004d9 <+12>:    mov    %eax,-0x4(%rbp)

   0x00000000004004dc <+15>:    mov    -0x4(%rbp),%eax

   0x00000000004004df <+18>:    mov    -0x14(%rbp),%edx

   0x00000000004004e2 <+21>:    add    %edx,%eax

   0x00000000004004e4 <+23>:    pop    %rbp

   0x00000000004004e5 <+24>:    retq  

End of assembler dump.

Give a 1-2 sentence description of the purpose of each instruction.

Instruction:	Purpose:
push %rbp
mov %rsp,%rbp
mov %edi,-0x14(%rbp)
mov -0x14(%rbp),%eax
add %eax,%eax
mov %eax,-0x4(%rbp)
mov -0x4(%rbp),%eax
mov -0x14(%rbp),%edx
add %edx,%eax
pop %rbp
retq

2. Assembly language understanding:

Write a C function that does what cars() does.
You won't be able to figure out the names of my parameters var(s) and local var(s); just make up your own name(s).

Answer 1

1)

push %rbp :
rbp is the frame pointer.It contains the return address of the function(caller) which called this function(callee). So it must be saved first on stack otherwise it does not go back to the function which called him. It is important when nested function calls are made and each called function must return to its base/parent function(prolog assembly function).

mov %rsp, %rbp :
this line sets the stack for the current function, where passed arguments can be accessed through %rbp register.the argument can be accessed through %rsp also. %rsp always points to top of the stack where %rbp always points to bottom of the stack.if this is not done then if some space is allocated on stack(for local variables) it will overwrite return address and arguments of the function. also %rbp is easy manipulation for push/pop operations.

mov %edi,-0x14(%rbp) :
Here we are fetching the first argument of the function and copying it on local variable(stack rbp - 20). On x86 architectures, all the arguments are passed through stack but on x86_64 architectures, these are first done using registers(for saving memory) and then stack. %edi,%esi,%edx,%ecx, %rdi,%rsi,%rdx... for 64 bit.So here passed argument is the type of int which takes only 4 byte but it is allocated as 8 byte, so %edi. -0x14(-20 in decimal). so %rbp contains base address and then arguments by their sizes(byte,word,dword,qword etc). so there are two variables in bar() function, one is function argument and another is local variable.

mov -0x14(%rbp),%eax :
Here we are copying value of the first argument into %eax register from stack frame(rbp - 20).This is opposite to above operation just in another register.

add %eax,%eax :
adding values of eax = eax+eax, which is first argument of the function bar().

mov %eax,-0x4(%rbp) :
Assign result of the above operation(add %eax,%eax) to local variable(rbp - 4). see following C program.

mov -0x4(%rbp),%eax :
Assign local variable value to %eax register for return value of the function bar().

pop %rbp :
Restore the base/return adress of the function.

retq :
   Returning the quad word(unsigned int,char*,unsigned long) depends on compiler implementation. Only ret is also possible because any ret jump to the base address.

2)
Here's the C program for cars(), where return type and local/argument type can be(int,unsigned int,unsigned long, long int, char * etc.) In assembly there is nothing like signed/unsigned. everything is signed and unsigned is checked by the sign bit which compiling C program.

int cars(int x)
{
    int y;
    y = x+x;
    return y;
}