Assembler Course

Lesson 1 • Computer Architecture Essentials

Covers CPU components, the fetch-decode-execute cycle, and memory hierarchy. Establishes the hardware context that makes assembly language meaningful.

Lesson 2 • Number Systems and Data Representation

Teaches binary, octal, hexadecimal, and two's complement arithmetic. Provides the numeric fluency required to read and write assembly operands accurately.

Lesson 3 • Assembly Language vs. High-Level Languages

Contrasts abstraction levels, compilation pipelines, and performance trade-offs. Motivates why low-level programming remains relevant in modern systems.

Lesson 1 • Memory Organization and Segmentation

Describes flat memory model, stack, heap, and code segments in a process address space. Grounds students in where data lives before addressing modes are introduced.

Lesson 2 • Addressing Modes in Depth

Covers immediate, register, direct, indirect, base-plus-offset, and scaled-index addressing. Students select the correct mode for any given data access pattern.

Lesson 3 • Flags and Status Registers

Explains the EFLAGS/RFLAGS register and individual flag bits set by arithmetic and logic operations. Prepares students for conditional branching in later chapters.

Lesson 1 • String and Block Instructions

Introduces MOVS, STOS, LODS, SCAS, and CMPS with REP prefixes for bulk data operations. Connects to efficient memory manipulation patterns used in real programs.

Lesson 2 • Data Movement Instructions

Teaches MOV, MOVZX, MOVSX, LEA, XCHG, and PUSH/POP semantics and constraints. Forms the foundation for all subsequent instruction usage.

Lesson 3 • Logic and Bitwise Instructions

Explains AND, OR, XOR, NOT, TEST, and CMP and their flag-setting behavior. Enables students to implement masking, toggling, and comparison operations.

Lesson 4 • Arithmetic Instructions

Covers ADD, SUB, MUL, IMUL, DIV, IDIV, INC, DEC, and NEG with flag effects. Students implement integer arithmetic routines and handle overflow conditions.

Lesson 1 • Unconditional Jumps and Labels

Covers JMP instruction forms, label definition, and short vs. near vs. far jump encoding. Establishes the mechanics of program counter manipulation.

Lesson 2 • Loop Constructs and LOOP Instruction

Teaches LOOP, LOOPE, and LOOPNE instructions alongside CX/ECX/RCX-based counting. Students implement counted loops and compare efficiency with Jcc alternatives.

Lesson 3 • Structured Control Flow Patterns

Translates while, do-while, for, and switch patterns into idiomatic assembly sequences. Reinforces clean label naming and fall-through discipline.

Lesson 1 • Stack Architecture and Operations

Explains the stack pointer, base pointer, push/pop mechanics, and stack growth direction. Provides the mental model needed to understand procedure frames.

Lesson 2 • Calling Conventions

Covers System V AMD64 ABI and Windows x64 calling conventions: argument registers, shadow space, and return values. Enables correct C-to-assembly interoperability.

Lesson 3 • Stack Frames and Local Variables

Teaches prologue and epilogue patterns, frame pointer setup, and local variable allocation. Students build procedures with correct frame management.

Lesson 4 • CALL and RET Mechanics

Details how CALL pushes the return address and RET pops it, including near and far variants. Students trace execution flow through nested procedure calls.

Lesson 1 • Arrays and Indexed Access

Covers one-dimensional and multi-dimensional array layout, element size scaling, and bounds checking. Connects scaled-index addressing to real array traversal.

Lesson 2 • Linked Lists and Dynamic Structures

Implements singly and doubly linked list traversal, insertion, and deletion in assembly. Demonstrates dynamic pointer chasing without high-level language support.

Lesson 3 • Pointers and Pointer Arithmetic

Teaches pointer dereferencing, pointer arithmetic, and null-pointer guards in assembly. Bridges C pointer semantics to assembly memory access patterns.

Lesson 1 • Multi-File Projects and Linking

Explains GLOBAL, EXTERN, and PUBLIC directives for cross-file symbol visibility. Students build and link multi-module assembly projects correctly.

Lesson 2 • Assembler Directives

Covers data definition directives (DB, DW, DD, DQ), section declarations, and alignment directives. Teaches how directives control object file layout.

Lesson 3 • Structured Macro Libraries

Organizes reusable macros into include files and applies include guards. Establishes professional code organization practices for large assembly projects.

Lesson 4 • Macro Definition and Expansion

Teaches single-line and multi-line macro syntax, parameters, and local labels. Students replace repetitive code blocks with parameterized macros.

Lesson 1 • Profiling and Performance Analysis

Uses performance counters, disassembly inspection, and benchmarking to identify bottlenecks. Students iterate on assembly code guided by quantitative profiling data.

Lesson 2 • Cache and Memory Optimization

Teaches cache-line awareness, prefetch instructions, and data layout for spatial locality. Students restructure data access patterns to minimize cache misses.

Lesson 3 • Inline Assembly in C Programs

Covers GCC extended inline assembly syntax: constraints, clobber lists, and volatile qualifiers. Students embed optimized assembly snippets inside C source files.

Lesson 4 • SIMD and Vector Instructions

Introduces SSE2 and AVX2 registers, data types, and packed arithmetic instructions. Students vectorize scalar loops to process multiple data elements per cycle.