Assembly (.asm, .s)

Overview

Assembly language is a low-level programming language that provides a human-readable representation of machine code instructions. Each assembly instruction corresponds directly to a machine language instruction, making it the closest programming language to the actual hardware. Assembly is crucial for system programming, embedded systems, performance-critical applications, and understanding how computers work at the fundamental level.

Technical Details

• File Extensions: .asm, .s, .S (case-sensitive on Unix)
• MIME Type: text/x-asm
• Category: Programming Language
• First Appeared: 1940s-1950s
• Paradigm: Imperative, procedural
• Platform: Architecture-specific (x86, ARM, MIPS, etc.)

Key Features

Direct Hardware Control

• Direct manipulation of CPU registers
• Memory addressing and management
• Hardware interrupt handling
• Precise timing control

Maximum Performance

• No overhead from high-level abstractions
• Optimal code generation possible
• Fine-grained control over execution
• Minimal memory footprint

Architecture Specific

• Each CPU architecture has its own assembly language
• Instruction sets vary between processors
• Register sets and addressing modes differ
• Platform-specific optimizations

x86-64 Assembly Examples

Basic Syntax and Structure

# AT&T Syntax (GAS - GNU Assembler)
.section .data
    msg: .ascii "Hello, World!\n"
    msg_len = . - msg

.section .text
.global _start

_start:
    # Write system call
    mov $1, %rax        # sys_write
    mov $1, %rdi        # stdout
    mov $msg, %rsi      # message
    mov $msg_len, %rdx  # length
    syscall

    # Exit system call
    mov $60, %rax       # sys_exit
    mov $0, %rdi        # exit status
    syscall

; Intel Syntax (NASM - Netwide Assembler)
section .data
    msg db 'Hello, World!', 0Ah
    msg_len equ $ - msg

section .text
global _start

_start:
    ; Write system call
    mov rax, 1          ; sys_write
    mov rdi, 1          ; stdout
    mov rsi, msg        ; message
    mov rdx, msg_len    ; length
    syscall

    ; Exit system call
    mov rax, 60         ; sys_exit
    mov rdi, 0          ; exit status
    syscall

Function Definitions and Calls

# Function to calculate factorial
.section .text
factorial:
    push %rbp           # Save base pointer
    mov %rsp, %rbp      # Set up stack frame
    
    cmp $1, %rdi        # Compare n with 1
    jle base_case       # Jump if n <= 1
    
    push %rdi           # Save n
    dec %rdi            # n - 1
    call factorial      # Recursive call
    pop %rdi            # Restore n
    mul %rdi            # n * factorial(n-1)
    jmp end_factorial
    
base_case:
    mov $1, %rax        # Return 1
    
end_factorial:
    pop %rbp            # Restore base pointer
    ret                 # Return

# Main function
main:
    mov $5, %rdi        # Argument: n = 5
    call factorial      # Call factorial(5)
    # Result is in %rax
    ret

Loops and Control Structures

# Loop to sum numbers 1 to n
sum_loop:
    mov $0, %rax        # sum = 0
    mov $1, %rcx        # i = 1
    
loop_start:
    cmp %rdi, %rcx      # Compare i with n
    jg loop_end         # Jump if i > n
    
    add %rcx, %rax      # sum += i
    inc %rcx            # i++
    jmp loop_start      # Continue loop
    
loop_end:
    ret                 # Return sum in %rax

# Conditional example
check_even:
    test $1, %rdi       # Test least significant bit
    jz is_even          # Jump if zero (even)
    
    mov $0, %rax        # Return 0 (odd)
    ret
    
is_even:
    mov $1, %rax        # Return 1 (even)
    ret

ARM Assembly Examples

Basic ARM Assembly

.text
.global _start

_start:
    @ Load immediate value
    mov r0, #42         @ r0 = 42
    mov r1, #13         @ r1 = 13
    
    @ Addition
    add r2, r0, r1      @ r2 = r0 + r1
    
    @ Multiplication (if supported)
    mul r3, r0, r1      @ r3 = r0 * r1
    
    @ Load from memory
    ldr r4, =data_value @ Load address of data_value
    ldr r5, [r4]        @ Load value from address in r4
    
    @ Store to memory
    str r2, [r4]        @ Store r2 to address in r4
    
    @ System call to exit
    mov r7, #1          @ Exit system call number
    swi 0               @ Software interrupt

.data
data_value: .word 100

ARM Function Example

.text
.global fibonacci

fibonacci:
    @ Function to calculate nth Fibonacci number
    @ Input: r0 = n
    @ Output: r0 = fibonacci(n)
    
    push {r1, r2, lr}   @ Save registers and link register
    
    cmp r0, #1          @ Compare n with 1
    ble fib_base        @ Branch if n <= 1
    
    mov r1, r0          @ Save n
    sub r0, r0, #1      @ n - 1
    bl fibonacci        @ Call fibonacci(n-1)
    mov r2, r0          @ Save result
    
    sub r0, r1, #2      @ n - 2
    bl fibonacci        @ Call fibonacci(n-2)
    add r0, r0, r2      @ fibonacci(n-1) + fibonacci(n-2)
    
    b fib_end

fib_base:
    @ Return n for base cases (0 or 1)
    b fib_end

fib_end:
    pop {r1, r2, lr}    @ Restore registers
    bx lr               @ Return

MIPS Assembly Examples

Basic MIPS Assembly

.data
    msg: .asciiz "Hello, MIPS!\n"
    
.text
.globl main

main:
    # Print string
    li $v0, 4           # Print string system call
    la $a0, msg         # Load address of string
    syscall
    
    # Addition example
    li $t0, 10          # Load immediate 10 into $t0
    li $t1, 20          # Load immediate 20 into $t1
    add $t2, $t0, $t1   # $t2 = $t0 + $t1
    
    # Exit program
    li $v0, 10          # Exit system call
    syscall

MIPS Function Example

.text
.globl gcd

gcd:
    # Greatest Common Divisor using Euclidean algorithm
    # $a0 = first number, $a1 = second number
    # Returns result in $v0
    
    beq $a1, $zero, gcd_end  # If b == 0, return a
    
    div $a0, $a1             # Divide a by b
    move $a0, $a1            # a = b
    mfhi $a1                 # b = remainder
    
    j gcd                    # Recursive call
    
gcd_end:
    move $v0, $a0            # Return value
    jr $ra                   # Return to caller

Development Tools

Assemblers

• GAS (GNU Assembler): Part of GNU binutils
• NASM: Netwide Assembler for x86
• MASM: Microsoft Macro Assembler
• YASM: Rewrite of NASM

Debuggers

• GDB: GNU Debugger with assembly support
• OllyDbg: Windows x86 debugger
• x64dbg: Modern Windows debugger
• Radare2: Reverse engineering framework

IDEs and Editors

• Visual Studio: With MASM integration
• Code::Blocks: Cross-platform development
• Vim/Emacs: With assembly syntax highlighting
• IDA Pro: Professional disassembler

Memory Management and Data Types

Data Declaration

.section .data
    # Byte data (8-bit)
    byte_var: .byte 255
    
    # Word data (16-bit)
    word_var: .word 65535
    
    # Double word (32-bit)
    dword_var: .long 4294967295
    
    # Quad word (64-bit)
    qword_var: .quad 18446744073709551615
    
    # String data
    string_var: .ascii "Hello"
    string_null: .asciz "Hello\0"
    
    # Array data
    int_array: .long 1, 2, 3, 4, 5
    
    # Uninitialized data
.section .bss
    buffer: .space 1024     # Reserve 1024 bytes

Pointer Arithmetic

# Working with arrays
.section .data
    numbers: .long 10, 20, 30, 40, 50
    
.section .text
array_sum:
    mov $numbers, %rsi      # Point to array
    mov $5, %rcx            # Number of elements
    mov $0, %rax            # Initialize sum
    
sum_loop:
    add (%rsi), %rax        # Add current element to sum
    add $4, %rsi            # Move to next element (4 bytes)
    loop sum_loop           # Decrement %rcx and loop if not zero
    
    ret                     # Return sum in %rax

Inline Assembly in C

GCC Inline Assembly

#include <stdio.h>

int add_assembly(int a, int b) {
    int result;
    
    // Inline assembly with AT&T syntax
    asm volatile (
        "addl %%ebx, %%eax"
        : "=a" (result)         // Output: result in EAX
        : "a" (a), "b" (b)      // Inputs: a in EAX, b in EBX
        :                       // No clobbered registers
    );
    
    return result;
}

// Example with memory operations
void memory_copy(void *dest, const void *src, size_t n) {
    asm volatile (
        "rep movsb"
        : "+D" (dest), "+S" (src), "+c" (n)
        :
        : "memory"
    );
}

int main() {
    int x = 10, y = 20;
    int sum = add_assembly(x, y);
    printf("Sum: %d\n", sum);
    return 0;
}

Microsoft Visual C++ Inline Assembly

#include <stdio.h>

int multiply_asm(int a, int b) {
    int result;
    
    __asm {
        mov eax, a      ; Load a into EAX
        mov ebx, b      ; Load b into EBX
        imul eax, ebx   ; Multiply EAX by EBX
        mov result, eax ; Store result
    }
    
    return result;
}

System Programming

System Calls

# Linux x86-64 system calls
.section .text

# Read from file
sys_read:
    mov $0, %rax        # sys_read
    mov %rdi, %rdi      # file descriptor
    mov %rsi, %rsi      # buffer
    mov %rdx, %rdx      # count
    syscall
    ret

# Write to file  
sys_write:
    mov $1, %rax        # sys_write
    mov %rdi, %rdi      # file descriptor
    mov %rsi, %rsi      # buffer
    mov %rdx, %rdx      # count
    syscall
    ret

# Open file
sys_open:
    mov $2, %rax        # sys_open
    mov %rdi, %rdi      # filename
    mov %rsi, %rsi      # flags
    mov %rdx, %rdx      # mode
    syscall
    ret

Interrupt Handling

# Simple interrupt handler (bare metal)
.section .text

keyboard_interrupt:
    pusha               # Save all registers
    
    # Read keyboard scancode
    in $0x60, %al       # Read from keyboard port
    
    # Process scancode (implementation specific)
    call process_keycode
    
    # Send End of Interrupt to PIC
    mov $0x20, %al
    out %al, $0x20
    
    popa                # Restore all registers
    iret                # Return from interrupt

Performance Optimization

SIMD Instructions

# SSE example for parallel addition
.section .data
    .align 16
    vector1: .float 1.0, 2.0, 3.0, 4.0
    vector2: .float 5.0, 6.0, 7.0, 8.0
    result:  .space 16

.section .text
vector_add:
    movaps vector1, %xmm0   # Load first vector
    movaps vector2, %xmm1   # Load second vector
    addps %xmm1, %xmm0      # Parallel addition
    movaps %xmm0, result    # Store result
    ret

Loop Optimization

# Optimized memory copy
fast_memcpy:
    mov %rdx, %rcx          # Copy count
    shr $3, %rcx            # Divide by 8 for qword copies
    rep movsq               # Copy 8 bytes at a time
    
    mov %rdx, %rcx          # Handle remaining bytes
    and $7, %rcx            # Modulo 8
    rep movsb               # Copy remaining bytes
    ret

Common Use Cases

Operating System Kernels

• Boot loaders and initialization code
• Interrupt and exception handlers
• Memory management routines
• Device drivers

Embedded Systems

• Microcontroller programming
• Real-time system components
• Hardware abstraction layers
• Signal processing routines

Performance-Critical Code

• Game engine inner loops
• Cryptographic algorithms
• Image and video processing
• Mathematical computations

Reverse Engineering

• Malware analysis
• Software protection understanding
• Binary analysis
• Vulnerability research

Learning Resources

• "Programming from the Ground Up" by Jonathan Bartlett
• "Assembly Language for x86 Processors" by Kip Irvine
• "Computer Organization and Design" by Patterson & Hennessy
• Online assembly tutorials and documentation
• CPU architecture manuals from Intel, AMD, ARM

Assembly language remains essential for system programming, embedded development, and understanding computer architecture at the lowest level, providing unmatched control over hardware resources and maximum performance optimization opportunities.