How Does Register Handling Affect Function Calls in IA32 Assembly?

[fsbadr]

Homework Statement

//this function is the callee
int func(int num1, int num2)
{
int t = num1 * num2;
return t - (num1 + num2);
}


//this is the caller
int main()
{
int a = 4;
int b = 8;
int c = func(a, b);
return 0;
}

When caller calls callee, callee does not need to worry about overwriting
the "caller save" registers (for instance, %eax). The system ensures that
any data that caller required and that happened to be stored in these
"caller save" registers would be saved and restored for caller. However,
if callee were to overwrite any of the "callee save" registers (for instance,
%ebx), then callee first must save the current contents of any such
register and then restore the contents before returning. Assume, in the
above example, that caller and callee each requires registers for its local
int variables, parameters, and return value.

Homework Equations

I have 6 registers I can use for assembly operations which are
%eax, %edx ,%ecx,%ebx, %edi, %esi, I cannot use anything else

The Attempt at a Solution

I have done the following, if someone could help me in this

pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %ecx ;; addressing modes -- copy n1 into ecx
movl 12(%ebp), %edx ;; addressing modes -- copy n2 into edx
imull (%ecx,%edx), %eax ;; multiply n1 * n2
addl %ecx,%edx ;; add n1 + n2
subl %ecx,%eax ;; t - (n1 + n2) and store value in eax
movl %ebp, %esp ;; reset the stack pointer
popl %ebp ;; reset the frame pointer
ret ;; return

 

[KataKoniK]

the value in eax

In this solution, I have used the registers %ecx and %edx for the parameters num1 and num2, and %eax for the return value. I have also used the registers %ebp and %esp for the stack frame. Since the callee does not need to worry about overwriting the "caller save" registers, I have not used any of them in my solution. However, if the callee were to overwrite any of the "callee save" registers, then it would first need to save the current contents of those registers and then restore them before returning. This could be done by pushing the values of those registers onto the stack at the beginning of the function and popping them off the stack before returning.

 

[piercas]

the value in eax

This code looks correct and efficient. One thing to note is that you do not need to reset the stack pointer and frame pointer at the end, as those are typically handled by the system when the function returns. Also, you may want to add some comments to explain what each line of code is doing for clarity. Overall, good job!