x86 Assembly Language Programming From Ground Up™

Set up the development environment by installing Visual Studio Community, enable desktop development with C++, configure MASM, create a test console project, build and run hello world to verify setup.

Set up a pure x86 assembly project in Visual Studio with MASM, create main.asm, and implement a start procedure that moves 213 into eax and adds 432, then inspect registers.

Install a MASM syntax highlighter for Visual Studio to improve readability of assembly code, highlighting directives, instructions, registers, and numbers with color-coded emphasis.

Trace the evolution of Intel x86 processors from the 8086 to modern core architectures, covering flat memory, 32-to-64-bit transitions, and SIMD extensions like sse, avx, and fma.

Compare Harvard and Von Neumann architectures. Highlight that Von Neumann uses a single memory bus and unified memory, while Harvard uses separate memories and two buses for simultaneous fetches.

Explore boolean algebra and truth tables to understand logic gates—AND, OR, NOT, and XOR—and how binary inputs X and Y create hardware functions with ICs like quad gates.

Explore how hardware and software relate through the virtual machine concept, from native L0 to readable L1, translation or interpretation, and Java bytecode on the JVM.

Explore binary counting and base conversions among base-2, base-10, and hexadecimal (base-16), and use 0b and 0x notations to write and understand code.

Examine x86 data types from byte to quadword, noting sizes in bytes and bits, including unsigned ranges for byte and word.

Explore the basic design of an x86 microcomputer, detailing the CPU, registers, clock, control unit, ALU, buses, and the fetch-decode-execute instruction cycle.

Explore the x86 operating modes—protected mode, real address mode, and system management mode (with the virtual 1886 mode)—and how memory segmentation enables isolation and safe multitasking.

Explore the evolution of x86 registers from 8086 to 64-bit x64, covering general purpose, segment, index, and instruction pointer registers and low/high byte access.

Explore backward compatibility of the general purpose registers across x64 and x86, showing how rax/eax/ax and ax/bx/cx map across 64-bit, 32-bit, and 16-bit access in a hands-on assembly project.

Explore x86 flags, including control and status flags, how they govern CPU operation and arithmetic results, and how overflow, sign, zero, carry, and parity flags signal outcomes and errors.

Explore the floating point unit and the x87 architecture with eight data registers. Learn about the IEEE 754-1985 standard, FPU control and status registers, and the supported memory operands.

Examine real address mode with 1 mb, protected mode with 4 gb per process, segmentation with 64 kb segments, and the flat memory model via the global descriptor table.

Identify how integer constants form with a sign, digits, and a radix for decimal, hex, binary. Note expressions are evaluated at assembly time; brackets highest and addition and subtraction lowest.

Explore directives versus instructions, including pseudo ops and common dot directives for code, data, and stack segments, and learn the basic instruction syntax with labels, mnemonics, operands, and optional comments.

Learn the simple x86 assembly program template, including dot directives, the flat memory model, code and data sections, and basic mov and sub instructions.

Declare variables in assembly in a Visual Studio MASM project by defining a data section with num1, num2, answer as dword, then add num1 and num2 and move to answer.

Explore data definition statements that allocate storage and initialize values with byte, sbyte, word, sword, dword, qword, and tword directives. Learn string definitions, null termination, and memory layout.

Discover how x86 uses little endian memory layout, placing the least significant byte at the first address, and compare it with big endian where the most significant byte comes first.

Learn to integrate c++ and x86 assembly in a visual studio project by implementing a reverse function in assembly called from c++, including prologue and epilogue concepts.

Explore x86 data transfer with operand types: immediate, register, and memory, and learn how one to three operands configure destination and source registers, memory references, and symbolic names.

Master the move instruction, transferring data from source to destination, and apply zero-extend or sign-extend to fit 8-bit, 16-bit, and 32-bit operands.

Understand direct offset operations by using a byte array and displacement to access memory without labels, moving the first byte into al and offsetting to reach subsequent bytes.

Explore x86 memory addressing modes by calculating effective addresses using base and index registers, scale factors, and displacement in 32-bit operands, with practical mov examples.

Explore the x86 assembly increment and decrement instructions, learn their syntax, and see how they add or subtract one from a single operand with examples.

Master data operators and directives in x86 assembly, including offset, type, length, and size operators, and use label and aligned directives to manage data sizing and alignment.

Write an x86 assembly program that sums the elements of an array using masm. Initialize a data section with a 32-bit array and loop to accumulate total in a register.

Write an x86 assembly program that scans an array to find the first non-zero value, using a loop, compare to zero, and branch to a found or not found path.

This lesson defines typedef-based pointer types for byte, word, and dword, builds data arrays, and uses pointers to access and move values into assembly registers.

Learn conditional branching with the jump instruction, transferring control to a labeled destination via an offset, then master the loop instruction, which decrements a counter and jumps until zero.

Learn to use and, or, and test instructions for bitwise operations on matching bits across registers, memory locations, and immediates, and perform compares with the cmp instruction.

Explore conditional jump instructions that branch to a destination label at level 2 when a status flag condition is true, such as the zero, carry, or overflow flags.

Show how to call an assembly procedure from C++ to compute the sum of three numbers, using a 386 module, prolog/epilogue, and eax return in a Visual Studio project.

Form signed multiplication and division using signed multiply and sign divide instructions. Pass data between C++ and assembly with pointers to return product, quotient, and remainder.

Learn C++ calling conventions and stack frame setup on x86, implement a calculate sum procedure in assembly, and compute sum, sum of squares, and sum of cubes for three inputs.

Experiment with x86 addressing modes by implementing a memory address function using a Fibonacci lookup table, demonstrating base, displacement, base+index, and base+index+scale in a C++ project.

Declare global C++ variables and use them in x86 assembly to map char, short, int, and long long to assembly types, illustrated by an addition routine.

Explore x86 conditional code instructions by implementing the minimum and maximum of three signed numbers using conditional jumps and conditional move instructions in an assembly and C++ test harness.