CPU Features & Registry

CPU Features & Registry

Learning Assembly starts with a hardware lecture.

Here are some of the key processor features relevant for learning Assembly language:

• Registers - Processors have a small number of registers that are used to store data and addresses. Registers provide the fastest way to access data since they are inside the processor. Some common registers are:

  • Accumulator: Used for storing results of arithmetic and logical operations.

  • Program Counter: Stores the address of the next instruction to be executed.

  • Index Registers: Used for indexing memory locations during array operations.

• Arithmetic Logic Unit (ALU) - The ALU performs arithmetic and logical operations on the data in registers or memory. It handles operations like addition, subtraction, AND, OR, etc.

• Control Unit - The control unit manages the flow of instructions by fetching instructions from memory, decoding them and controlling the ALU and other components.

• Memory - The processor accesses data from memory locations using memory addresses. Memory provides larger storage but is slower compared to registers.

• Instruction Set - The set of machine instructions that a processor can execute. Assembly language consists of mnemonics that map to the processor's instruction set.

Registers are extremely important when writing Assembly code since you have to use registers to store and manipulate data. Common operations in Assembly involve moving data to and from registers, performing calculations using registers, and accessing memory locations.

Computer Memory

Here is an explanation of memory, memory addresses, memory performance and dual-channel memory:

Memory: Computer memory stores data and instructions for processing by the CPU. It is used to store both program instructions and data. There are two main types of memory:

  • RAM (Random Access Memory): Stores data and instructions currently being used. RAM is volatile, meaning it loses data when power is turned off.

  • ROM (Read Only Memory): Stores data that cannot be altered. ROM is non-volatile, meaning it retains data even when power is off.

Memory Addresses: Each memory location in RAM has a unique address. The CPU accesses data from memory by specifying the memory address. Memory addresses are binary numbers.

Memory Performance: Memory performance is measured in terms of:

  • Speed: Measured in nanoseconds (time taken to access data from memory). Faster memory has lower latency.

  • Bandwidth: Measured in bytes per second. Higher bandwidth means more data can be transferred in a given time.

  • Capacity: Measured in gigabytes. A larger memory capacity can store more data and instructions.

Dual Channel Memory: Dual channel memory uses two independent RAM modules connected to the CPU. This improves memory performance by:

  • Increasing bandwidth: Each channel provides full bandwidth. So total bandwidth is doubled.

  • Reducing latency: The CPU can access two memory modules simultaneously, effectively halving the latency.

Dual channel memory is commonly used in high-performance systems like gaming PCs to improve performance.

CPU Memory Cache

Modern CPUs have multiple levels of cache memory to improve memory performance:

  • L1 Cache: The fastest and smallest cache, typically 8-32 KB in size, is built into the CPU core. It has the lowest latency.

  • L2 Cache: A larger cache of around 256 KB to 1 MB. It is shared between CPU cores on the same die.

  • L3 Cache: The largest cache of around 2-8 MB. It is shared between all CPU cores. It has the highest latency.

  • Main Memory: Off-chip RAM which is much larger in size but has the highest latency.

When programming in Assembly, it is important to optimize for cache performance:

  • Cache hits: When data requested by the CPU is already present in the cache, it is called a cache hit. This results in fast access times.

  • Cache misses: When data needs to be fetched from main memory, it is called a cache miss. This results in higher latency.

To optimize for caches:

  • Use registers as much as possible. Data in registers has zero latency.

  • Access data in a sequential manner. This increases the cache hit rate.

  • Use smaller, local data structures that fit in the cache.

  • Minimize data-dependent branches as they reduce instruction-level parallelism.

In summary, the CPU cache hierarchy significantly impacts the performance of Assembly code. Optimizing for cache hits and reducing cache misses can improve performance by reducing memory latency.

X86-64 Registers

Here is an overview of the key CPU registers for the x86-64 architecture:

RAX - The primary accumulator/result register. Used to store results of arithmetic and logic operations.

RBX - Used as a base register for memory addressing. Also used as a general-purpose register.

RCX - Used as a counter register for loops. Also used as a general-purpose register.

RDX - Used as a secondary accumulator/result register. Also used as a general-purpose register.

RSI - Used as a source index register for string operations and memory addressing.

RDI - Used as a destination index register for string operations and memory addressing.

RBP - Used as a base pointer register. Points to the base of the current stack frame.

RSP - Stack pointer register. Points to the top of the current stack frame.

R8-R15 - Additional general purpose registers.

RIP - Instruction pointer register. Contains the address of the next instruction to execute.

EFLAGS - Contains status and control flags like carry flag, zero flag, etc.

Some other important registers:

  • CS - Code segment register

  • SS - Stack segment register

  • DS, ES, FS, GS - Data segment registers

In x86-64 Assembly, you typically perform operations using registers and then store the result in a register. The key is to take advantage of the large number of registers available to optimize your code. Also, control flow instructions like jumps, calls and returns manipulate the RIP register.


Yes, pointers are supported natively in the Assembly language. Pointers allow you to store the memory addresses of variables in other variables.

You can define pointers and use them in Assembly using the following registers:

  • EBP - Base pointer, points to the bottom of the stack frame

  • ESP - Stack pointer, points to the top of the stack

  • EIP - Instruction pointer, points to the next instruction to execute

  • EAX, EBX, ECX, EDX - General purpose registers that can store pointers

For example, to define a pointer in Assembly:

; Define a variable
number DW 100

; Define a pointer 
ptr DW 0

; Make the pointer point to the number variable
lea eax, number
mov ptr, eax

Here we:

  1. Define a number variable

  2. Define a ptr pointer and initialize it to 0

  3. Use LEA to get the memory address of number and store it in EAX

  4. Move EAX to ptr, so now ptr contains the memory address of number

We can then use the ptr pointer to access the value at number:

; Access value using pointer
mov eax, [ptr] ; eax now contains 100

So in summary, yes - pointers are fully supported in Assembly using registers like EAX, EBX, EBP, ESP, and EIP.

You can define pointers, make them point to variables, and then dereference the pointers to access the underlying variables.

Arithmetic Logic Unit

The Arithmetic Logic Unit (ALU) is a critical component of the x86-64 architecture that performs arithmetic and logical operations. Understanding how the ALU works is important for learning x86-64 assembly language programming.

The ALU has two main inputs - two operands from either registers or memory. It then performs an operation specified by the instruction and stores the result in a destination register.

The main operations performed by the ALU are:

  • Arithmetic operations: Addition, subtraction, multiplication, division and remainder.

  • Logical operations: AND, OR, XOR, NOT. These operate on individual bits.

  • Bitwise shift operations: Left shift, right shift, rotate.

In x86-64 assembly, you specify the operands and operation using instructions like:

  • add - Addition

  • sub - Subtraction

  • mul - Multiplication

  • and - Bitwise AND

  • or - Bitwise OR

  • xor - Bitwise XOR

  • shl - Left shift

For example:

add rax, rbx ; Add contents of RBX to RAX and store result in RAX

xor rcx, rcx ; Set RCX to 0 using XOR

The ALU also has flags that are set based on the result of an arithmetic operation. These flags are used in conditional jumps and are stored in the EFLAGS register. Important flags are:

  • Zero flag (ZF) - Set if the result is zero

  • Carry flag (CF) - Set if there is a carry or borrow

  • Sign flag (SF) - Set based on the sign of the result

So in summary, to program in x86-64 assembly, you need to understand:

  1. How to specify the operands - Using registers or memory

  2. The ALU operations supported - add, sub, mul, and, or, etc.

  3. How the result is stored - In a destination register

  4. How the flags are set - To enable conditional jumps

CPU Control Unit

The control unit is a component of the CPU that controls the flow of instructions by performing the following functions:

  1. Fetch the next instruction to execute from memory. This involves incrementing the instruction pointer (RIP register in x86-64) to point to the next instruction.

  2. Decode the fetched instruction to determine what operation needs to be performed. This involves figuring out the operands, operation code and destination register.

  3. Generate control signals to direct the flow of data within the CPU. This includes:

  • Sending the operands to the ALU

  • Controlling registers to read from and write to

  • Controlling whether data comes from registers or memory

  • Enabling the ALU to perform the required operation

  • Storing the result in the destination register

  1. Control the execution of instructions in the correct sequence. This involves:
  • Handling jumps and branches by updating the instruction pointer

  • Handling function calls and returns by using the stack

  • Handling interrupts and exceptions

  1. Coordinate the overall data flow and timing within the CPU. This ensures that all components operate in sync.

So in summary, the control unit orchestrates the fetch-decode-execute cycle of each instruction by determining what needs to be done and directing other components within the CPU to perform the required tasks.

This is important for assembly language programming because you need to understand:

  1. How instructions are fetched from memory

  2. How operands are read from registers or memory

  3. How the ALU operation is determined from the operation code

  4. How jumps, calls and returns are handled

  5. How the result is stored in the destination register

All of this is controlled by the control unit, so having a good mental model of its functions helps in writing efficient assembly code for the x86-64 architecture.


Here is a conclusion of the CPU knowledge presented so far and what we should learn next to start programming in x86-64 Assembly:

We have covered the main components of the CPU that are important for Assembly programming:

  • Registers: To store operands and results

  • ALU: To perform arithmetic and logic operations

  • Control Unit: To control the flow of instructions

These components work together to execute instructions in a CPU. We understood how:

  • Instructions specify the operands and operations using registers

  • The operands are sent to the ALU

  • The ALU performs the required operation

  • The result is stored in a destination register

  • The control unit coordinates the fetch-decode-execute cycle

While this level of understanding is helpful, there are still a few more things we need to learn to actually start programming in x86-64 Assembly:

  1. The x86 Instruction Set: We need to learn the specific instructions in detail, like mov, add, sub, jmp, call, etc.

  2. Assembly Syntax: We need to learn how to write assembly code using mnemonics, operands, directives, etc.

  3. Assembly to Machine Code: We need to understand how to assemble our assembly code into the machine code that the CPU can actually execute.

  4. Debugging Techniques: We need to learn how to debug assembly code using tools like an assembler, disassembler and debugger.

  5. Calling Conventions: We need to understand how functions are called and returned from in x86-64 Assembly.

So in summary, while having a conceptual understanding of the CPU components is helpful, we still need to dive into the specifics of the x86 instruction set, assembly syntax, assembly tools and calling conventions to actually start writing x86-64 Assembly programs.

External Resources

Here are some resources for learning more:

  1. Wikipedia: https://en.wikipedia.org/wiki/X86-64

  2. OSDev: https://wiki.osdev.org/CPU_Registers_x86-64

Hope these resources help you learn more about the x86-64 CPU architecture!

Disclaim: At this time of writing I have little knowledge about Assembly language. All I do is ask questions for AI to explain step by step what I need to know to become an Assembly developer. I ask the questions so you don't have to. Learn and prosper. 🖖