Read the original article here.

---

Understanding Assembly Language: The Bridge to Machine Code

An Essential Concept for Building from Scratch

When embarking on the journey of building a computer from scratch, you quickly move beyond the physical components and delve into how they are instructed. At the very heart of a computer's operation is machine code – the raw, binary language the processor understands. But writing programs directly in sequences of 0s and 1s is incredibly difficult, tedious, and error-prone for humans. This is where assembly language comes in.

Assembly language serves as the critical bridge between human-readable instructions and the binary code that the computer's processor executes. It's the lowest level of programming language that still offers a symbolic representation, making it possible for humans to write and understand the operations happening right on the silicon. For anyone seeking to truly grasp how a computer works from the ground up, understanding assembly language is indispensable.

Assembly Language (ASM or asm): A low-level programming language that has a very strong, typically one-to-one, correspondence between its instructions and the architecture's native machine code instructions. It uses symbolic names (mnemonics) and other aids to make machine code more readable and writable for humans.

The Core Relationship: Assembly and Machine Code

Imagine you have a set of levers and switches that control a complex machine. Machine code is like trying to control the machine by flipping the levers and switches in a specific, complex sequence of "on" (1) and "off" (0). Assembly language is like having a list of simple labels and instructions – like "TurnLeverA Up," "SwitchB Off," "Combine LeverA and SwitchB Result" – that directly correspond to those lever/switch combinations.

The fundamental principle of assembly language is its one-to-one correspondence with machine code instructions. Almost every line of assembly code translates directly into one machine instruction. This close relationship means that assembly language is entirely architecture-specific. An assembly program written for an Intel x86 processor will not run on an ARM processor, because the underlying machine instructions and the processor's architecture (like the number and type of registers) are fundamentally different.

Historically, programming began with directly manipulating machine code, often by physically wiring circuits or toggling switches on the computer's console. The invention of assembly language was a massive leap forward, replacing hard-to-remember numeric codes with simple, symbolic names (mnemonics).

Machine Code: The set of instructions executable directly by a computer's CPU. It consists of binary values representing operations (opcodes) and their operands. It is the lowest level of programming language.

Mnemonic: A symbolic name used in assembly language to represent a single machine language instruction or opcode. Mnemonics are easier for humans to remember than binary or hexadecimal opcodes. Examples include MOV, ADD, JMP.

Key Elements of Assembly Language Syntax

While the specific syntax varies depending on the processor architecture and the particular assembler program being used, most assembly languages share core elements:

1. Opcode Mnemonics: These are the primary instructions that tell the CPU what to do (e.g., move data, add numbers, jump to a different part of the program).
2. Operands: Most instructions need data or locations to operate on. Operands specify the source and/or destination of data (e.g., a specific register, a memory address, a constant value).
3. Labels: Symbolic names assigned to memory locations. They make it easy to jump to specific instructions or refer to data storage areas without having to manually calculate numerical memory addresses.
4. Assembly Directives (Pseudo-ops): Commands for the assembler program itself, not translated into machine instructions. They control the assembly process, define data areas, set program location, etc.
5. Comments: Text ignored by the assembler, used by programmers to explain the code. Absolutely essential in assembly for readability.

Let's look at an example:

START:      MOV     AX, 5       ; Load the value 5 into register AX
            ADD     AX, [myVar] ; Add the value from memory location 'myVar' to AX
            JMP     FINISH      ; Jump to the label 'FINISH'
myVar       DW      10          ; Define a data word named 'myVar' with initial value 10
FINISH:     HLT                 ; Halt the processor

In this simple (architecture-agnostic) example:

• START and FINISH are labels.
• MOV, ADD, JMP, HLT are opcode mnemonics.
• AX, 5, [myVar], FINISH are operands.
• ; introduces a comment.
• DW is a data directive.

The Role of the Assembler

Writing assembly code requires a special tool to convert it into the executable machine code the CPU understands. This tool is called an assembler.

Assembler: A utility program that translates assembly language source code into machine code (object code). It performs tasks like converting mnemonics and syntax into numerical opcodes, calculating addresses, and resolving symbolic names (labels).

The assembler takes the text file containing the assembly language program (the source code) and produces an object file containing the binary machine code. It handles the tedious tasks:

• Translating Mnemonics: Turning MOV into the correct binary opcode for the specific operation and operands.
• Resolving Labels: Replacing symbolic names like START or myVar with the actual numerical memory addresses determined during the assembly process.
• Calculating Expressions: Evaluating simple arithmetic or logical expressions used in operands or directives.
• Processing Directives: Following instructions on how to arrange code/data, reserve memory, etc.

Because assembly language is tied to the architecture, assemblers are also architecture-specific. An assembler for x86 won't understand ARM assembly code. Furthermore, even for the same architecture, different assemblers might use slightly different syntaxes. The classic example is the difference between Intel syntax (used by MASM, NASM) and AT&T syntax (used by GNU Assembler, GAS) for x86 processors. While they look different (e.g., MOV destination, source vs. mov source, destination and register/memory notation), a line in one syntax typically has a direct equivalent in the other, producing the same machine code.

Assembler Passes

The process of converting assembly code to machine code isn't always done in a single linear read. A common technique is using multiple passes:

• One-Pass Assembler: Reads the source code once. If it encounters a label that hasn't been defined yet (a "forward reference"), it makes a note of it. Later, after the symbol is defined, the assembler (or a subsequent linker/loader) goes back and "patches" the instructions that needed that address. This was useful in early computing with limited memory.
• Multi-Pass Assembler: Reads the source code two or more times. The first pass is used primarily to identify all labels and determine their memory addresses, building a symbol table. Subsequent passes (usually just a second pass) then use this complete symbol table to generate the final machine code, easily resolving all forward and backward references without needing later patching. This is the more common approach today.

Symbol Table: A data structure created by the assembler during the first pass (in a multi-pass assembler) or built dynamically (in a one-pass assembler) that stores the names and addresses (or values) of all labels and symbols defined in the assembly source code.

Multi-pass assemblers can also sometimes perform simple optimizations, like selecting the shortest possible instruction variant (e.g., a short jump vs. a long jump) once the final distances between instructions are known.

Language Design: Diving Deeper

Beyond mnemonics and simple operands, assembly languages incorporate features to help structure programs and manage data.

Opcode Mnemonics and Extended Mnemonics

As mentioned, opcodes represent instructions. These instructions often operate on operands which can be:

• Immediate Values: A constant value directly included in the instruction (MOV AX, 5).
• Registers: Small, fast storage locations within the CPU (MOV AX, BX).
• Memory Addresses: Locations in the main system memory. These can be specified directly or calculated using various addressing modes (e.g., based on register values, offsets).

Some mnemonics can represent a family of related machine instructions depending on the operands. For example, MOV in x86 assembly can move data between registers, between a register and memory, or an immediate value to a register or memory. The assembler looks at the types of operands provided to choose the correct underlying machine instruction byte sequence.

Opcode: The portion of a machine language instruction that specifies the operation to be performed (e.g., addition, subtraction, data movement). It is represented symbolically by a mnemonic in assembly language.

Operand: The data or location upon which a machine instruction operates. Operands can be immediate values, registers, or memory addresses.

Addressing Mode: The method used by a processor instruction to specify the location of an operand. This can include direct addressing, indirect addressing, register addressing, indexed addressing, etc.

Extended Mnemonics or Synthetic Instructions are assembler conveniences. They are mnemonics that don't correspond to a unique machine instruction but are aliases for a specific instruction combined with a specific operand pattern. A common example is NOP (No Operation). Many architectures don't have a dedicated NOP instruction. Instead, assemblers might define NOP as an extended mnemonic for an instruction that does nothing useful, like XCHG AX, AX (exchange register AX with itself) on x86. The assembler translates NOP into the machine code for XCHG AX, AX.

Data Directives

Assembly languages provide directives specifically for defining and initializing data areas in memory. These are crucial for allocating space for variables or constants used by the program.

Data Directive: An assembly language command that tells the assembler to reserve space in memory for data and optionally initialize it with specific values. They define the size and type of the data element. Examples include DB (Define Byte), DW (Define Word), DD (Define Doubleword).

Examples:

myByte DB 25         ; Define a byte variable 'myByte' with initial value 25
myString DB "Hello", 0 ; Define a string of bytes, ending with a zero byte
bufferTimes10 DD 10  dup(?) ; Reserve 10 doublewords (40 bytes) for a buffer, uninitialized

Data directives also handle concepts like data alignment, which ensures data starts at memory addresses optimized for processor access.

Assembly Directives (Pseudo-operations)

These commands control the assembler and the assembly process itself. They don't generate machine code directly (though some data directives are sometimes categorized here).

Assembly Directive (Pseudo-op): A command embedded in assembly source code that provides instructions to the assembler during the assembly process. They do not translate directly into executable machine code but affect how the assembler operates, manages symbols, defines data, or structures the output.

Examples of pseudo-ops:

• ORG: Set the memory address where the following code/data should be placed.
• EQU: Assign a symbolic name (a symbol) to a constant value or address. BufferSize EQU 1024.
• SECTION or SEGMENT: Structure the code/data into logical blocks (e.g., .text for code, .data for initialized data, .bss for uninitialized data).
• END: Mark the end of the source file.
• Conditional assembly directives (IF, ENDIF): Allow parts of the code to be included or excluded based on conditions evaluated at assembly time.

Labels, which provide symbolic names for memory locations, are often defined using their position in the code or with directives like EQU. They are critical for writing readable jump instructions and accessing data.

Macros: Adding Power and Abstraction

Many assemblers, especially macro assemblers, support macros. Macros are a powerful feature that allows a programmer to define a name that represents a sequence of assembly language instructions or directives. When the assembler encounters the macro name, it replaces (expands) it with the predefined sequence before proceeding with the normal assembly process.

Macro (in assembly): A named block of assembly source code (including instructions, directives, and templates) that can be defined once and then inserted into the code multiple times by simply using the macro's name. The assembler replaces the macro name with the block of code during the assembly process (macro expansion).

Macros can take parameters, making them highly flexible. A macro definition can include variables that are replaced by the specified parameters during expansion.

Example (conceptual):

; Define a macro named 'LOAD_A_CONSTANT' that takes one parameter, 'value'
LOAD_A_CONSTANT MACRO value
    MOV AX, value
ENDM

; Use the macro
    LOAD_A_CONSTANT 10   ; This line is replaced by "MOV AX, 10" by the assembler
    LOAD_A_CONSTANT [var] ; This line is replaced by "MOV AX, [var]" by the assembler

Macros are distinct from subroutines or functions. A subroutine is a block of code called at runtime using instructions like CALL and RET. A macro expansion happens at assembly time, inserting the code sequence directly into the program's text. This is similar in concept to the #define directive in C, but assembly macros can be much more sophisticated, often including conditional logic, loops (processed by the assembler), and variable manipulation within the macro definition itself.

Macros allow programmers to:

• Reduce repetitive coding by defining common sequences once.
• Create higher-level abstractions or "pseudo-instructions" that are more complex than basic opcodes but easier to use.
• Customize code based on parameters at assembly time (e.g., generating a sorting routine tailored for a specific data type or key).
• Add structure to assembly programs, making them look less like a flat list of instructions.

The power of macro assemblers means that complex systems can be built, and the resulting assembly code can be significantly more readable and maintainable than raw assembly without macros.

Support for Structured Programming

While assembly language is fundamentally unstructured (relying heavily on jumps/GOTOs), macro packages have been developed to introduce structured programming constructs. These packages define macros that emulate high-level control flow like IF/THEN/ELSE, SWITCH/CASE, and loops (FOR, WHILE).

By using these macros, programmers can write assembly code that looks structurally similar to code in languages like C or Pascal, reducing the reliance on unstructured jumps and mitigating the risk of creating "spaghetti code." The macros translate these structured constructs into the appropriate conditional and unconditional jump instructions the CPU understands.

Historical Context and Evolution

In the earliest days of computing (1940s-1950s), programming was machine code. Assembly language, introduced in the late 1940s and early 1950s (with pioneers like Kathleen and Andrew Donald Booth and David Wheeler), was a revolutionary step. It eliminated the need for programmers to work directly with binary numbers and calculate memory addresses manually, drastically reducing errors and speeding up development.

For decades, assembly language was the primary way to write programs, both for low-level system software (operating systems, device drivers) and high-level applications (business software, scientific programs). Iconic systems like the Burroughs MCP operating system, early home computer games on platforms like the Apple II and Commodore 64, and key PC software like Lotus 1-2-3 were heavily or entirely written in assembly.

The rise of high-level programming languages (like FORTRAN, COBOL, Algol, C) starting in the late 1950s gradually shifted the majority of software development away from assembly language. High-level languages offer much greater productivity, readability, and portability across different computer architectures. As computing power increased, the performance penalty of using compiled high-level languages became less significant for many applications. Fred Brooks famously cited the move to high-level languages as the "most powerful stroke for software productivity."

Current Usage and Relevance Today

Despite the dominance of high-level languages, assembly language remains vital in specific domains. For someone building a computer from scratch, understanding these domains highlights why this low-level perspective is still necessary.

Assembly language is currently used for:

1. Boot Code and Firmware: The initial code that runs when a computer powers on (like the BIOS on PCs). This code initializes hardware, tests memory, and prepares the system to load an operating system. It must run before any higher-level language runtime or OS services are available.
2. Operating System Kernels: Core parts of operating systems, especially those dealing directly with the processor, memory management, and interrupt handling, are often written in assembly. This allows for precise control over system resources and privileged instructions.
3. Device Drivers: Software that allows the operating system to communicate with hardware devices. Drivers need to interact directly with device registers and handle hardware interrupts, tasks often requiring assembly language for precise timing and low-level access.
4. Embedded Systems and Microcontrollers: In systems with limited resources (memory, processing power), assembly language is sometimes used to achieve maximum performance or fit code into small memory footprints. This is common in appliances, automotive systems, and simple control devices.
5. Performance-Critical Sections: While compilers are highly optimized, there are still specific algorithms or inner loops where hand-tuned assembly can provide significant speed improvements. This is often seen in multimedia processing (video/audio codecs), scientific computing libraries (linear algebra), and graphics rendering engines, especially when leveraging processor-specific instruction sets (like SIMD instructions - Single Instruction, Multiple Data).
6. Accessing Processor-Specific Features: Some specialized instructions available on a processor may not be directly exposed or optimally used by high-level language compilers. Assembly provides direct access to these instructions (e.g., specific bit manipulation instructions, cryptographic instructions).
7. Real-Time Systems: Applications where operations must complete within strict time deadlines (e.g., flight control, medical equipment). Assembly offers maximum predictability and control over execution time, avoiding potential delays from high-level language runtimes, garbage collection, or complex OS scheduling.
8. Reverse Engineering and Security: Analyzing existing software (binaries) often involves disassembling machine code back into assembly language. This is crucial for understanding how programs work, identifying vulnerabilities, or recovering lost source code. Malware analysts also use assembly to understand viruses and other malicious code.
9. New or Specialized Architectures: When a completely new processor is developed, the first tools available are usually an assembler and perhaps a C compiler. Writing system software initially might require assembly before a full suite of high-level language tools is mature.
10. Educational Purposes: Perhaps most importantly for "building from scratch," studying assembly language is fundamental to understanding how computers work at their most basic level.

The Enduring Educational Value

Even if you never write a full application in assembly language, studying it provides invaluable insights into:

• Computer Architecture: How the CPU, memory, and I/O devices interact.
• Data Representation: How numbers, characters, and other data types are stored and manipulated in binary form.
• Memory Management: Concepts like the stack, heap, and different memory segments.
• The Instruction Cycle: How the CPU fetches, decodes, and executes instructions.
• How Compilers Work: Understanding assembly shows you the target output of compilers and helps you appreciate how high-level constructs are translated into low-level operations.

Understanding assembly is like learning the fundamental mechanics of an engine. You can drive a car without this knowledge, but you can't truly understand how it works, diagnose deep problems, or design a new engine without it. For building a computer from scratch, this foundational knowledge is not just helpful; it's essential.

Typical Applications Summarized

Assembly language plays a vital role in areas where low-level control, performance, or direct hardware interaction is paramount:

• System boot sequences (BIOS, UEFI)
• Operating system kernels and low-level libraries
• Device drivers
• Embedded systems and firmware
• High-performance computing libraries (e.g., optimized math routines)
• Real-time operating systems and applications
• Compilers (as an intermediate output)
• Reverse engineering and security analysis tools
• Virtual machine monitors and emulators

Conclusion

Assembly language stands as the indispensable layer between human programmers and the raw machine code executed by the processor. While its role in general application development has diminished with the rise of high-level languages, its importance in system programming, performance optimization, embedded systems, and understanding the fundamental workings of a computer remains undiminished. For anyone undertaking "The Lost Art of Building a Computer from Scratch," mastering assembly language is not just a technical skill, but a crucial step in truly comprehending the digital machine from the ground up. It provides the vocabulary and perspective needed to bridge the gap from high-level code down to the binary pulses within the circuits.

---