تمرير الوسائط والقيم المرجعة

When you write a procedure (like a function in C), it often needs data to work with, and it might produce a result.

This lesson explores how data, called arguments, is sent into a procedure, and how the procedure sends a return value back out.

Procedures are like mini-programs. To make them useful, they need to communicate with the main program or other procedures.

• Arguments: Input data for the procedure to process.
• Return Value: The result produced by the procedure.

Without this communication, procedures would be very limited!

To ensure procedures can talk to each other, there are rules called calling conventions.

These rules dictate:

• How arguments are passed (registers or stack).
• Which registers a procedure can modify.
• How return values are transmitted.

We'll look at common ways for x86.

For a small number of arguments, it's efficient to pass them using registers.

A common convention (like System V ABI on Linux) uses specific registers for the first few arguments:

• RDI (1st argument)
• RSI (2nd argument)
• RDX (3rd argument)
• RCX (4th argument)

For 32-bit (x86), these would be EDI, ESI, etc.

Here, a procedure _add_two takes two numbers in EBX and ECX (acting as arguments) and returns their sum in EAX.

When there are many arguments, or if registers are already in use, the stack is used to pass arguments.

• Arguments are PUSHed onto the stack before the CALL instruction.
• The called procedure accesses these arguments relative to the EBP (base pointer) or ESP (stack pointer).

The order of pushing matters! Often, arguments are pushed in reverse order (last argument first).

After CALL, the return address is on the stack. If arguments were pushed, they are below the return address.

Inside the procedure, EBP is typically saved and then set to ESP to create a stable base for accessing arguments and local variables.

• [EBP+8]: First argument (after saved EBP and return address)
• [EBP+12]: Second argument
• And so on...

This example shows _multiply_two taking two arguments from the stack and returning their product in EAX.

Just like arguments, return values are most commonly passed back in registers for simplicity and speed.

• For 32-bit x86, the EAX register is typically used for integer return values.
• For 64-bit x86, RAX is used.
• Floating-point values might use ST(0) (x87 FPU) or XMM0 (SSE).

If a procedure has no explicit return value, EAX/RAX might still contain leftover data, so don't rely on it.

What if you need to return a large structure or an array?

• Memory Pointer: The caller might pass a pointer to a memory location where the procedure should store its result.
• Stack: Less common for simple types, but complex structures could theoretically be built on the stack by the called procedure and then accessed by the caller.

For most basic cases, stick to registers for return values.

Consider a 32-bit x86 assembly procedure designed to take two integer arguments and return their sum. If the arguments are pushed onto the stack, and the return value is placed in EAX, what is the correct instruction to return from the procedure and clean up the stack?

In this lesson, we explored how procedures communicate by passing data:

• Arguments are inputs, passed via registers (for few) or the stack (for many).
• Return values are outputs, typically placed in a designated register (like EAX/RAX).
• Calling conventions provide rules for this data exchange.

Mastering these concepts is key to writing robust assembly programs!