How bad am I doing with x86 assembly?

[DumbestPerson224]

Body

SECTION .text
    GLOBAL _addIntegers
    GLOBAL _subIntegers
    GLOBAL _mulInteger
    GLOBAL _divInteger

_addIntegers:
   push ebp
   mov  ebp, esp 
   mov eax, [ebp + 8]
   mov ebx, [ebp + 16]
   add eax, ebx
   mov esp, ebp 
   pop ebp 
   ret 

_subIntegers:
     push ebp 
     mov ebp, esp
     mov eax, [ebp + 8]
     mov ebx, [ebp + 16]
     sub eax, ebx 
     mov esp, ebp
     pop ebp 
     ret 

_mulInteger:
     push ebp 
     mov ebp, esp 
     mov eax, [ebp + 8]
     mul eax 
     mov esp, ebp
     pop ebp 
     ret

_divInteger:
     push ebp 
     mov ebp, esp 
     mov eax, [ebp + 8]
     div eax 
     mov esp, ebp 
     pop ebp 
     ret 

Guidelines

• I have read and understood this category's guidelines before making this post.

[lucatosc]

There are some issues in your x86 assembly code, as well as a few improvements that can be made. Let's examine each function:

1. General Structure:

   • Your functions generally follow the correct prologue (saving ebp and setting up the stack), but there are some things that need fixing.

2. Addition Function (_addIntegers):

   • This function looks good overall. It correctly takes two integers from the stack, adds them, and puts the result in eax.

3. Subtraction Function (_subIntegers):

   • This function also looks correct, following the same pattern as the addition function.

4. Multiplication Function (_mulInteger):

   • The issue here is with the mul instruction. The mul instruction does not take an argument, it multiplies the value in eax with the value in the operand (you need to move the second integer into another register before calling mul).
   • To fix this, you might want to load the second integer into ebx first and then perform mul ebx.

   _mulInteger:
       push ebp
       mov ebp, esp
       mov eax, [ebp + 8]  ; First integer
       mov ebx, [ebp + 12] ; Second integer
       mul ebx             ; Multiply eax (first integer) by ebx (second integer)
       mov esp, ebp
       pop ebp
       ret

5. Division Function (_divInteger):

   • The div instruction also requires the second operand to be specified, and the first operand is implicitly assumed to be in eax.
   • You need to ensure you're not dividing by zero, as this would cause an exception.
   • You should move the divisor (the second integer) into another register (like ebx) before using it in a div operation.

   _divInteger:
       push ebp
       mov ebp, esp
       mov eax, [ebp + 8]  ; Numerator
       mov ebx, [ebp + 12] ; Denominator
       cmp ebx, 0          ; Check for division by zero
       je .div_by_zero     ; If zero, handle the error case
       div ebx             ; Divide eax by ebx
       jmp .end            ; Jump to end
   .div_by_zero:
       ; Handle division by zero error (optional, maybe set eax to 0 or raise a flag)
       xor eax, eax        ; Set result to 0 (if preferred)
   .end:
       mov esp, ebp
       pop ebp
       ret

6. Final Cleanup:

   • Make sure all functions handle their return values correctly and consistently. By convention, the result of an operation is often placed in eax, which you are doing correctly.

With these adjustments, your functions should work properly. Here’s a quick summary of each:

• Make sure you properly retrieve the arguments from the stack using the correct offsets. Based on the calling convention, the first parameter is at [ebp + 8], and the second is at [ebp + 12].
• Ensure that your multiplication and division operations correctly use the appropriate registers.

Overall, you're on the right track! Just a few tweaks are required for the multiplication and division functions to work correctly.
🤝

[DumbestPerson224]

So am I bad at assembly?

[DumbestPerson224]

lr;dr

SECTION .text
    GLOBAL _addIntegers
    GLOBAL _subIntegers
    GLOBAL _mulInteger
    GLOBAL _divInteger

_addIntegers:
   push ebp
   mov  ebp, esp 
   mov eax, [ebp + 8]
   mov ebx, [ebp + 16]
   add eax, ebx
   mov esp, ebp 
   pop ebp 
   ret 

_subIntegers:
     push ebp 
     mov ebp, esp
     mov eax, [ebp + 8]
     mov ebx, [ebp + 16]
     sub eax, ebx 
     mov esp, ebp
     pop ebp 
     ret 

_mulInteger:
     push ebp 
     mov ebp, esp 
     mov eax, [ebp + 8]
     mul eax 
     mov esp, ebp
     pop ebp 
     ret

_divInteger:
     push ebp 
     mov ebp, esp 
     mov eax, [ebp + 8]
     mov ebx, [ebp + 12]
     test ebx, ebx 
     jz .divisionByZeroError
     jnz .divide

     .divisionByZeroError:
          mov eax, -1
          push eax 

     .divide:
          div eax
          xor eax, eax ; eax = 0 Execution complete without any errors 
          push eax 
     
     pop eax 
     mov esp, ebp 
     pop ebp 
     ret  

I fixed some of the issues

[lucatosc]

good.

[lucatosc]

thank you.