Appeler l’assembleur depuis C

Why would you mix C/C++ and Assembly? It might seem old-fashioned, but there are powerful reasons!

• Performance: For critical code sections, hand-optimized assembly can be faster than compiler-generated code.
• Hardware Access: Interact directly with hardware features not exposed by C/C++.
• Specific Instructions: Use special CPU instructions (e.g., for cryptography or multimedia) directly.
• Legacy Code: Integrate with existing assembly routines or operating system components.

It allows you to get the "best of both worlds" – C's high-level structure with assembly's low-level power.

When C calls an assembly function, they need to agree on a "contract" for how things work. This contract is called a calling convention.

It defines:

• How arguments are passed (registers or stack).
• Who cleans up the stack after the call.
• Which registers the called function must preserve.

For modern 64-bit Linux/macOS systems, the System V AMD64 ABI is standard. We'll focus on this.

To make an assembly function callable from C, you need to declare it as global. This tells the linker that the function can be accessed from other files.

The basic structure looks like this:

• Use the global directive.
• Define your function with a label (often prefixed with an underscore, like _my_function, though not strictly required by System V ABI, it's a common practice).
• Include your assembly instructions.
• End with a ret instruction to return control to the caller.

From the C side, an assembly function is just like any other function defined elsewhere. You declare it using the extern keyword.

The function prototype in C must exactly match what the assembly function expects in terms of arguments and return type.

For example, if your assembly function takes two long integers and returns a long, your C prototype would be: extern long my_assembly_func(long a, long b);

Under the System V AMD64 ABI, the first six integer or pointer arguments are passed via specific registers:

• 1st argument: RDI
• 2nd argument: RSI
• 3rd argument: RDX
• 4th argument: RCX
• 5th argument: R8
• 6th argument: R9

Any additional arguments are pushed onto the stack from right to left.

When your assembly function finishes, it places its return value into a specific register so C can retrieve it.

• For integer or pointer return values, use the RAX register.
• For floating-point values, use the XMM0 register.

After placing the result, the assembly function simply executes ret to jump back to the C code that called it.

Let's create an assembly function to add two numbers. This file would typically be named my_add.asm.

Pay attention to how arguments are received in RDI and RSI, and the result is placed in RAX.

Now, let's write the C code that uses our assembly function. This file would typically be named main.c. Remember to declare it with extern.

To compile and link:

nasm -f elf64 my_add.asm -o my_add.o

gcc main.c my_add.o -o my_program

./my_program

When your assembly function runs, it might use various registers. Some registers are caller-saved (caller must save them if it needs them later), and others are callee-saved (the assembly function must save and restore them if it modifies them).

Common callee-saved registers (x64): RBX, RBP, RSP, R12, R13, R14, R15.

If your assembly function modifies a callee-saved register, you must PUSH its value at the start and POP it back before returning.

Based on the System V AMD64 ABI, which register would typically hold the third integer argument passed to an assembly function from C?

Great job! You've learned the fundamentals of calling assembly code from C.

• We understood why you'd link C and assembly.
• We explored calling conventions, focusing on the System V AMD64 ABI.
• You saw how to declare functions on both the assembly and C sides.
• You learned how arguments are passed (registers) and return values are received (RAX).
• We touched upon register preservation rules to avoid unexpected side effects.

This skill is vital for low-level optimization and system interaction!