5 Assembly Concepts

Assembly and processor instructions

Assembly language is a human-readable way to express operations supported by a processor. Each instruction directs the CPU to do something, such as add values, load data, or change the next instruction to execute. Assembly is architecture-specific: RISC-V, for example, has its own registers and instruction names. An assembler translates assembly into machine code, while labels and shorthand make programs easier to write and organize.

Keep the architecture in mind when reading examples: an instruction available on one processor may not exist on another.

Registers and instruction forms

A register is a small, fast storage location inside the CPU. RISC-V integer registers are named x0 through x31; familiar ABI names describe common uses. For example, zero always reads as zero, ra holds a return address, sp is the stack pointer, t0–t6 are temporary registers, and a0–a7 are commonly used for arguments and return values.

An instruction consists of a mnemonic—the operation name—and operands that identify the values or locations it uses. In this example, add combines register values, while addi adds a constant:

Some familiar assembly forms are pseudoinstructions: assembler-provided shorthand translated into real instructions. Examples include li for loading an immediate value, mv for moving a value, and ret for returning from a procedure.

Labels, branches, and control flow

A label names a location in a program so a branch or jump can refer to it without requiring the programmer to calculate an address. A branch changes the normal instruction sequence when its condition is true. For example, beq t0, t1, equal transfers execution to equal if the register values match; otherwise, execution continues with the next instruction.

Branches connect assembly to familiar control structures. A conditional branch can express an if decision. A label combined with a backward branch can form a loop. Normally, the program counter advances through instructions; when a branch is taken, execution continues at its destination.

Procedures and calling conventions

A procedure is a named block of instructions that performs a task. A caller transfers control to the procedure, which returns control to the instruction after the call. Procedures coordinate through a calling convention: shared rules for passing arguments and results and for handling registers.

In the standard RISC-V convention, a registers carry arguments and return values; the first argument and return value use a0. The ra register holds the return address, and sp points to the stack. A procedure must follow ABI rules about which registers it is required to preserve.

RISC-V assemblers commonly accept call name and ret as pseudoinstructions for procedure control flow. If a procedure calls another procedure, it may need to save its own return address first, because the new call updates ra.

Translating an algorithm into assembly

To translate an algorithm into assembly, identify its values and control flow, then assign values to registers or memory and express the operations with instructions. This procedure sums the positive integers up to the input n; if n is zero or negative, it returns zero. The input arrives in a0, and the result is returned in a0.

The first branch handles inputs that should produce zero. Otherwise, the loop adds the counter to the running total, increases the counter, and branches back while the counter is no greater than n. When the loop ends, the result is placed in a0 and the procedure returns. For input $n = 4$, the result is $1 + 2 + 3 + 4 = 10$.

Takeaway: Identify the algorithm’s assignments, decisions, repetitions, and return value; then map them to registers, instructions, labels, and branches.