Assembly Course

Lesson 1 • Assembly Language vs. Machine Code

Contrasts mnemonics, opcodes, and binary encoding to show how assemblers translate source to object code. Learners understand the one-to-one mapping between assembly and machine instructions.

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 raw machine values.

Lesson 3 • Setting Up the Development Environment

Guides installation of an assembler, linker, and debugger toolchain. Learners produce and run their first minimal program before advancing to instruction syntax.

Lesson 4 • Computer Architecture Essentials

Covers CPU components, memory hierarchy, and the bus system. Establishes the hardware context that makes every assembly instruction meaningful.

Lesson 1 • Addressing Modes in Depth

Covers immediate, direct, register-indirect, base-plus-offset, and scaled-index modes. Learners select the correct mode for each memory-access scenario.

Lesson 2 • Shift and Rotate Instructions

Introduces SHL, SHR, SAR, ROL, RCL, and their count operands. Learners use shifts for fast multiplication, division, and bit-field extraction.

Lesson 3 • Instruction Format and Operand Types

Explains opcode fields, operand sizes, and prefix bytes. Connects syntax rules to the binary encoding introduced in Chapter 1.

Lesson 4 • Arithmetic and Logic Instructions

Teaches ADD, SUB, MUL, DIV, AND, OR, XOR, and NOT with flag effects. Learners perform integer arithmetic and bitwise operations on register and memory operands.

Lesson 1 • Unconditional and Short Jumps

Covers JMP with near, far, and short encodings and their displacement limits. Learners choose the correct jump form to avoid assembler range errors.

Lesson 2 • Flags and Conditional Jumps

Maps each conditional jump mnemonic to the flag combination it tests. Learners implement if-else and switch logic using CMP, TEST, and Jcc instructions.

Lesson 3 • String and Block Operations

Covers MOVS, CMPS, SCAS, LODS, STOS with REP prefixes for bulk data operations. Learners process arrays and buffers efficiently without explicit loop bodies.

Lesson 4 • Structured Control Flow Patterns

Translates nested if-else, switch-case, and break/continue into clean assembly idioms. Learners write readable, maintainable branch code using consistent label conventions.

Lesson 1 • Stack Architecture and Management

Explains stack growth direction, stack pointer discipline, and alignment requirements. Learners manipulate the stack safely without corrupting adjacent data.

Lesson 2 • Argument Passing and Return Values

Covers register-based and stack-based argument passing for common calling conventions. Learners write procedures that accept multiple arguments and return scalar and aggregate values.

Lesson 3 • Stack Frame Construction

Covers prologue and epilogue patterns using PUSH RBP, MOV RBP RSP, and LEAVE. Learners build frames that correctly allocate local variables and save caller registers.

Lesson 4 • CALL and RET Mechanics

Traces how CALL pushes the return address and RET pops it to resume the caller. Learners understand the exact stack state at each point in a call sequence.

Lesson 1 • Arrays and Pointer Arithmetic

Covers element-size scaling, base-plus-index access, and bounds awareness. Learners traverse and modify arrays of bytes, words, and double words in assembly.

Lesson 2 • Dynamic Memory Allocation

Interfaces with OS heap allocation system calls to request and release memory. Learners implement a simple allocator loop and handle allocation failure.

Lesson 3 • Structs and Record Layout

Maps C-style struct fields to fixed offsets and explains padding for alignment. Learners access struct members using base-register-plus-offset addressing.

Lesson 4 • Linked Lists and Stack Structures

Builds singly linked lists and software stacks using dynamic allocation and pointer chaining. Learners insert, delete, and traverse nodes entirely in assembly.

Lesson 1 • Console Input and Output

Implements read and write system calls for stdin and stdout with buffer management. Learners build reusable print-string and read-line routines.

Lesson 2 • Process Control System Calls

Uses exit, fork, exec, and wait calls to manage process lifecycle. Learners write a program that spawns a child process and collects its exit status.

Lesson 3 • System Call Interface Fundamentals

Explains the system call number, argument registers, and kernel-entry mechanism. Learners invoke a minimal write call and verify the return value.

Lesson 4 • Error Handling and Robustness

Checks return values, maps error codes to messages, and implements retry logic. Learners produce programs that degrade gracefully on system call failure.

Lesson 1 • Interrupt Architecture Overview

Explains maskable and non-maskable interrupts, the interrupt vector table, and priority levels. Learners map interrupt sources to handler addresses in the vector table.

Lesson 2 • CPU Exceptions and Fault Handling

Covers divide-by-zero, invalid opcode, page fault, and general protection fault handlers. Learners install exception handlers that log faults and recover or terminate cleanly.

Lesson 3 • Memory-Mapped I/O and Device Registers

Accesses device control registers through memory addresses using volatile-aware load/store patterns. Learners toggle a hardware output by writing to a mapped register address.

Lesson 4 • Port-Mapped I/O

Uses IN and OUT instructions to read and write hardware device registers via I/O ports. Learners implement a polling loop for a simple hardware peripheral.

Lesson 1 • SIMD Fundamentals with Vector Instructions

Introduces packed integer and floating-point operations using vector registers. Learners vectorise a scalar loop to process multiple data elements per instruction.

Lesson 2 • Instruction Scheduling and Pipelining

Covers pipeline hazards, data dependencies, and reordering rules for throughput. Learners reorder instruction sequences to eliminate stalls in a sample loop.

Lesson 3 • Branch Elimination and Branchless Code

Replaces conditional jumps with conditional moves, bit tricks, and arithmetic predicates. Learners convert branch-heavy code to branchless equivalents and measure the speedup.

Lesson 4 • Cache Optimisation Strategies

Applies spatial and temporal locality principles to data layout and access patterns. Learners restructure array traversals to reduce cache misses and improve throughput.