0xax/asm Assembly Programming Tutorials

This repository provides a series of blog posts designed to teach assembly programming. The current content focuses exclusively on the x86_64 processor architecture and the GNU Linux operating system.

Topics covered include:

• x86_64 processor architecture basics
• Writing, building, and running assembly programs
• Linux program structure
• Memory allocation (stack and heap)
• System calls and OS interaction
• Floating-point number representation
• Calling assembly code from C programs

Floating-point numbers in assembly are represented using three main data types, which correspond to IEEE Standard 754. These formats differ in their bit-width and accuracy, mapping to standard C types:

• Single-precision: 32-bit (corresponds to C float)
• Double-precision: 64-bit (corresponds to C double)
• Double-extended precision: 80-bit (corresponds to C long double)

Note that floating-point numbers are approximations of real values, which can lead to precision issues in computations (e.g., 0.1 + 0.2 not exactly equaling 0.3).

The stack is a LIFO (last-in, first-out) memory region used for:

• Temporary Data Storage: Overcoming the limits of the sixteen general-purpose registers (rax, rbx, rcx, rdx, rdi, rsi, rbp, rsp, and r8 through r15).
• Function Calls: Storing the return address so that when a function finishes, the rip register can be restored to the address following the call instruction.
• Parameter Passing: Accessing function arguments that cannot fit in registers.
• Local Variables: Storing variables local to a function's scope.

The casm directory provides three distinct patterns for assembly and C interoperability:

1. casm1: Demonstrates how to call a C function from assembly code.
2. casm2: Demonstrates the use of GCC inline assembly within C.
3. casm3: Demonstrates how to call an assembly function from C code.

Use the .data section to define variables with initialized values, such as system call numbers, file descriptors, and string constants. Use equ for constant definitions and db for byte definitions.

section .data
        SYS_WRITE equ 1
        SYS_EXIT equ 60
        STD_OUT equ 1
        EXIT_CODE equ 0
        NEW_LINE db 0xa
        WRONG_ARGC_MSG  db "Error: expected two command-line arguments", 0xa
        WRONG_ARGC_MSG_LEN equ 43

To trigger a system call directly using the syscall instruction in Linux x86_64, you must follow specific calling conventions to pass arguments via registers:

1. System Call Number: Pass in the rax register.
2. Arguments: The first six parameters are passed in this specific order:
   • 1st argument: rdi
   • 2nd argument: rsi
   • 3rd argument: rdx
   • 4th argument: r10
   • 5th argument: r8
   • 6th argument: r9
3. Execution: Invoke the syscall instruction.
4. Result: The return value is provided in the rax register.

Floating-point operations in x86_64 use special XMM registers (xmm0 through xmm15) which are 128 bits wide. These are part of the SIMD extension set.

Calling Convention:

• Function Arguments: Floating-point arguments are passed in XMM registers. The first argument goes in xmm0, the second in xmm1, up to xmm7. Additional arguments are passed on the stack.
• Return Values: Floating-point return values are stored in the xmm0 register.