Introduction to Assembly

Introduction to Assembly Language

Assembly language is a low-level programming language that is specific to a particular computer architecture. It provides a human-readable representation of machine code, making it easier to write programs that directly interact with hardware.

What is Assembly Language?

Assembly language is a symbolic representation of machine code. Each assembly language instruction corresponds to one machine language instruction. Unlike high-level languages, assembly is not portable between different processor architectures.

Why Learn Assembly?

Understanding Computer Architecture: Learn how processors actually work
Performance Optimization: Write highly optimized code for critical sections
Embedded Systems: Essential for programming microcontrollers and devices with limited resources
Reverse Engineering: Understand how compiled programs work at the lowest level
Security Research: Analyze malware and exploit vulnerabilities

Basic Concepts

Assembly language programming involves working with:

Registers: Small storage locations in the CPU
Memory: RAM where data and instructions are stored
Instructions: Commands that tell the CPU what to do
Addressing Modes: Different ways to access memory

Simple x86 Assembly Example

Here's a simple "Hello, World!" program in x86 assembly for Linux:


section .data
    hello db 'Hello, World!', 0xA  ; String with newline
    len equ $ - hello              ; Length of the string

section .text
    global _start

_start:
    ; Write the string to stdout
    mov eax, 4        ; sys_write system call
    mov ebx, 1        ; file descriptor (stdout)
    mov ecx, hello    ; pointer to string
    mov edx, len      ; string length
    int 0x80          ; call kernel

    ; Exit the program
    mov eax, 1        ; sys_exit system call
    mov ebx, 0        ; exit status
    int 0x80          ; call kernel

Assembling and Linking

To assemble and link the program using NASM on Linux:


nasm -f elf hello.asm    # Assemble to object file
ld -m elf_i386 -s -o hello hello.o  # Link to create executable
./hello                  # Run the program

Common x86 Registers

Register	Purpose
EAX	Accumulator (used for arithmetic operations)
EBX	Base (used as pointer to data)
ECX	Counter (used in loops)
EDX	Data (used in I/O operations)
ESI	Source index (string operations)
EDI	Destination index (string operations)
ESP	Stack pointer
EBP	Base pointer (stack frames)

Basic Instructions

Instruction	Description
MOV	Move data between registers/memory
ADD/SUB	Add/Subtract values
INC/DEC	Increment/Decrement a value
JMP	Unconditional jump
CMP	Compare two values
CALL/RET	Call and return from subroutines
PUSH/POP	Stack operations

Advantages of Assembly

Performance: Maximum control over hardware resources
Size: Can produce very small executables
Direct Hardware Access: Can access all processor features
No Compiler Overhead: You control exactly what instructions are generated

Disadvantages of Assembly

Complexity: More difficult to write and maintain
Portability: Tied to specific processor architectures
Development Time: Takes longer to write equivalent functionality
Error-Prone: Easy to make mistakes with memory and registers

Next Steps

Now that you understand the basics of assembly language, you can explore more advanced topics: