Assembly Language Study Notes

Arithmetic Instructions

Understand how ADD, SUB, ADC, SBB, MUL, IMUL, DIV, IDIV, INC, DEC, and NEG compute results and update the FLAGS register in x86 assembly.

Arrays in Assembly

How fixed-size, contiguous arrays are declared, laid out in memory, and indexed using scaled addressing in x86-64 assembly.

Assembly Language Interview Questions

Common assembly language interview topics — registers, stack mechanics, calling conventions, and debugging scenarios — with worked explanations.

Assembly Optimization Basics

Core techniques for writing faster assembly code: instruction selection, register allocation, loop unrolling, and avoiding pipeline stalls.

Assembly Language Quick Reference

A condensed reference covering common x86-64 instructions, registers, flags, and addressing syntax for quick lookup.

Conditional Jumps

Learn how x86 assembly implements if/else logic using flag-testing conditional jump instructions like JE, JNE, JG, and JL.

CPU Registers Explained

A practical guide to what CPU registers are, the main categories on x86-64, and how assembly instructions use them to do work.

Data Movement Instructions (MOV, PUSH, POP)

Learn how MOV, PUSH, POP, XCHG, and LEA move data between registers and memory in x86 assembly without performing arithmetic.

Data Types and Directives

Learn how DB, DW, DD, DQ, RESB, and EQU declare initialized data, reserve uninitialized space, and define constants across .data, .bss, and .text.

Debugging Assembly with GDB

Practical GDB workflows for stepping through raw instructions, inspecting registers and memory, and setting breakpoints in assembly-level code.

Interfacing Assembly with C

How to call C functions from hand-written assembly and expose assembly routines to C, following the System V AMD64 calling convention.

Interrupts Explained

How hardware interrupts, software interrupts, and CPU exceptions divert execution to handler routines, and how the IDT ties it all together.

Logical and Bitwise Instructions

Master AND, OR, XOR, NOT, TEST, shifts, and rotates for masking, toggling, and manipulating individual bits in x86 assembly.

Loops in Assembly

Discover how high-level for and while loops are built from conditional jumps, counters, and the dedicated LOOP instruction in x86 assembly.

Memory Addressing Modes

How assembly instructions specify where an operand's value actually lives — immediate, register, direct, and indexed addressing explained with examples.

Pointers and Indirection

How addresses, dereferencing, pointer arithmetic, LEA, and multiple levels of indirection work at the machine level in x86-64 assembly.

Procedures and Calling Conventions

Learn how assembly functions are called, how arguments and return values are passed, and how the stack frame is built and torn down.

Recursion in Assembly

See how recursive functions are implemented at the machine level using the call stack, and why stack depth and register preservation matter.

Reverse Engineering with Assembly

How to read disassembled and decompiled code to recover program logic, recognize compiler-generated patterns, and identify common function idioms.

SIMD and Vector Instructions

How SSE and AVX let a single instruction operate on multiple data elements at once, and the alignment and transition rules that govern using them correctly.

Strings in Assembly

How byte-sequence strings are terminated, measured, copied, and compared in x86 assembly, including the REP-prefixed string instructions.

Structures in Assembly

How fixed-layout structures are declared with NASM's struc directive, addressed by named offset, nested, and arrayed in x86-64 assembly.

System Calls Explained

How assembly programs ask the operating system kernel to perform privileged work like reading files, allocating memory, and exiting a process.

The Assembly Toolchain (Assembler, Linker)

How assembly source files travel from text to a runnable executable via an assembler, object files, and a linker.