title: C Code represented as Assembler Code - How to interpret?
body: <p>I got this short C Code.</p>
  
  <pre><code>#include &lt;stdint.h&gt;
  uint64_t multiply(uint32_t x, uint32_t y) {
  
  uint64_t res;
  res = x*y;
  return res;
  }
  
  int main() {
  
  uint32_t a = 3, b = 5, z;
  z = multiply(a,b);
  return 0;
  }
  </code></pre>
  
  <p>There is also an Assembler Code for the given C code above.
  I don't understand everything of that assembler code. I commented each line and you will find my question in the comments for each line.</p>
  
  <p>The Assembler Code is:</p>
  
  <pre><code>.text
  multiply:
       pushl  %ebp  // stores the stack frame of the calling function on the stack
       movl   %esp, %ebp // takes the current stack pointer and uses it as the frame for the called function
       subl   $16, %esp // it leaves room on the stack, but why 16Bytes. sizeof(res) = 8Bytes
       movl   8(%ebp), %eax // I don't know quite what "8(%ebp) mean? It has to do something with res, because
       imull  12(%ebp), %eax // here is the multiplication done. And again "12(%ebp).
       movl   %eax, -8(%ebp) // Now, we got a negative number in front of. How to interpret this?
       movl   $0, -4(%ebp) // here as well
       movl   -8(%ebp), %eax // and here again.
       movl   -4(%ebp), %edx // also here
       leave
       ret
  main:
       pushl  %ebp // stores the stack frame of the calling function on the stack
       movl   %esp, %ebp // // takes the current stack pointer and uses it as the frame for the called function
       andl   $-8, %esp // what happens here and why?
       subl   $24, %esp // here, it leaves room for local variables, but why 24 bytes? a, b, c: the size of each of them is 4 Bytes. So 3*4 = 12
       movl   $3, 20(%esp) // 3 gets pushed on the stack
       movl   $5, 16(%esp) // 5 also get pushed on the stack
       movl   16(%esp), %eax // what does 16(%esp) mean and what happened with z?
       movl   %eax, 4(%esp) // we got the here as well
       movl   20(%esp), %eax // and also here
       movl   %eax, (%esp) // what does happen in this line?
       call   multiply  // thats clear, the function multiply gets called
       movl   %eax, 12(%esp) // it looks like the same as two lines before, except it contains the number 12
       movl   $0, %eax // I suppose, this line is because of "return 0;"
       leave
       ret
  </code></pre>