Coursify

Register-Reference vs Memory-Reference Instructions: Detailed Study with Examples

Register-Reference vs Memory-Reference Instructions: Detailed Study with Examples

Verified Sources
Nov 4, 2026

“Register reference” and “memory reference” describe what an instruction’s operand points to: a CPU register (fast, internal storage) versus main memory (slower, requires address calculation and load/store).

At a high level:

  • Register reference instructions operate on register contents.
  • Memory reference instructions read or write memory locations.
  • Many instruction sets also have an explicit separation between data-processing (often register-to-register) and load/store (register↔memory). This is especially clear in RISC designs. 3

Core concept: operands and addressing

For memory operands, the CPU must determine an effective address using an addressing mode such as:

  • Base + displacement (e.g., [base + offset])
  • Base + index * scale + displacement
  • PC-relative addressing (common in some ISAs)

In contrast, register operands usually map directly to a register specifier with no effective-address computation.

Mermaid overview of operand categories:

Key terms

  • Addressing mode
  • Effective address
  • Load instruction
  • Store instruction

Note: Exact syntax varies by ISA (x86, ARM, RISC-V, etc.), but the operand intent—register vs memory—follows the same underlying idea. 3

Footnotes

  1. Intel 64 and IA-32 Architectures Software Developer’s Manual (Instruction-Set Reference): ModR/M and SIB addressing details. (Source URL: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html) - Official Intel ISA manual landing page covering encoding and operand types. ↩ ↩2

  2. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩ ↩2

  3. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩ ↩2

Register vs Memory Addressing (conceptual walkthrough)

x86/IA-32: Register operands vs memory operands (ModR/M and SIB)

On x86, an instruction can reference either:

  • a register (register operand)
  • a memory location described by an addressing form (memory operand)

x86 encodes operand kinds using mechanisms described in the ISA reference, including ModR/M (selects addressing form and register/memory) and SIB (used for scale-index-base addressing).

Example 1: Register reference operand (conceptual)

Consider the idea:

  • ADD rax, rbx adds two register values.
  • Both operands are registers, so no effective address is needed.

In assembly-like form (syntax varies by architecture and assembler):

  • ADD Rdst, Rsrc where both are registers ⇒ register reference.

Example 2: Memory reference operand (conceptual)

Consider:

  • ADD rax, [rbx] adds rax and the 8-byte value stored at memory address in rbx.

Here:

  • [rbx] is a memory operand
  • the CPU uses rbx as part of an effective address and performs a load before the arithmetic.

Example 3: Base + index*scale + displacement (memory operand)

Memory operands can express:

  • base + index*scale + displacement

This is where SIB (Scale-Index-Base) becomes relevant to x86 encoding.

Mermaid data-flow (memory operand requires a load):

Footnotes

  1. Intel 64 and IA-32 Architectures Software Developer’s Manual (Instruction-Set Reference): ModR/M and SIB addressing details. (Source URL: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html) - Official Intel ISA manual landing page covering encoding and operand types. ↩ ↩2

ARM: Load/store with register addressing vs memory addressing (LDR/STR)

ARM architectures (especially in their common assembly forms) emphasize separating computation from memory access:

  • Data-processing instructions typically operate on registers.
  • Memory access instructions like LDR (load) and STR (store) read/write memory using an addressing mode.

ARM instruction set documentation defines how loads/stores use a base register, optional offset, and how those forms map to effective addresses.

Example 1: Register reference (register-to-register)

Conceptually:

  • ADD r0, r1, r2 computes r0 = r1 + r2
  • all operands are registers ⇒ register reference

Example 2: Memory reference: load (LDR)

Conceptually:

  • LDR r0, [r1] means:
    • compute effective address from r1 (here, simplest form)
    • load MEM[r1] into r0

So:

  • register reference: ADD uses register operands
  • memory reference: LDR performs memory access

Example 3: Memory reference: store (STR)

Conceptually:

  • STR r2, [r1] means:
    • compute effective address from r1
    • store r2 into MEM[r1]

Key learning goal: Identify whether an operand is bracketed / dereferenced (or otherwise marked as memory) in the assembly syntax, indicating a memory reference.

Footnotes

  1. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩ ↩2

RISC-V: Loads/stores use base+offset register addressing

RISC-V uses a clean load/store model:

  • arithmetic instructions use only registers
  • memory access happens only through lw, lh, sw, etc., with an address formed from a base register plus an immediate offset.

RISC-V ISA documentation explains that load/store instructions take an offset addressing form: offset(rs1) (effective address = rs1 + offset).

Example 1: Register reference (register-to-register)

Conceptually:

  • add x5, x6, x7 ⇒ x5 = x6 + x7 (no memory access)

Example 2: Memory reference: load

Conceptually:

  • lw x5, 8(x6) ⇒ x5 = MEM[x6 + 8]

This is a memory reference because the instruction reads from memory at the computed effective address.

Example 3: Memory reference: store

Conceptually:

  • sw x5, 8(x6) ⇒ MEM[x6 + 8] = x5

Footnotes

  1. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

How to classify an operand as register-reference vs memory-reference

  1. 1
    Step 1

    Look for explicit dereference/brackets (e.g., [base+off]), or explicit load/store mnemonics (LDR/STR, lw/sw). These typically indicate memory reference. 3

    Footnotes

    1. Intel 64 and IA-32 Architectures Software Developer’s Manual (Instruction-Set Reference): ModR/M and SIB addressing details. (Source URL: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html) - Official Intel ISA manual landing page covering encoding and operand types. ↩

    2. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩

    3. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

  2. 2
    Step 2

    If the instruction must compute an effective address (base/index/scale/offset/PC-relative), it’s a memory operand. If it only selects a register, it’s register reference.

  3. 3
    Step 3

    On load/store ISAs (common in ARM/RISC-V styles), arithmetic is register-only; memory is handled by loads/stores. That separation is central to classifying the behavior. 2

    Footnotes

    1. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩

    2. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

  4. 4
    Step 4

    For memory reference, model an implicit load before compute (or store after compute). Register-reference instructions directly consume register values.

  5. 5
    Step 5

    If data moves from memory to a register, it’s a load; if from register to memory, it’s a store. Mnemonics and operand ordering tell you the direction. 2

    Footnotes

    1. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩

    2. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

Register vs Memory Operand Characteristics

High-level comparison of what the CPU must do for each kind of operand.

Common pitfalls and clarifications

Pro Tip: Build a mental model

When you see a memory operand, mentally insert: “compute effective address → load/store memory”. When you see only registers, treat the instruction as pure computation on internal state.

Pro Tip: Brackets/dereference are not optional in your reading

In many assembly syntaxes, brackets or parentheses are the only signal that an operand is memory-referenced. If you miss that marker, you mispredict side effects and correctness.

Instruction behavior lifecycle (memory-reference case)

Identify operand type

Decode

The CPU determines whether the operand is a register operand or a memory operand (via instruction encoding fields). "

Footnotes

  1. Intel 64 and IA-32 Architectures Software Developer’s Manual (Instruction-Set Reference): ModR/M and SIB addressing details. (Source URL: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html) - Official Intel ISA manual landing page covering encoding and operand types. ↩

Compute effective address

Address calculation

For memory operands, compute EA using base/index/scale/offset or PC-relative rules. 3"

Footnotes

  1. Intel 64 and IA-32 Architectures Software Developer’s Manual (Instruction-Set Reference): ModR/M and SIB addressing details. (Source URL: https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html) - Official Intel ISA manual landing page covering encoding and operand types. ↩

  2. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩

  3. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

Load or store

Data movement

Execute load (memory → register) or store (register → memory). 2"

Footnotes

  1. ARM Architecture Reference Manual / ARM instruction set documentation: Load/store instructions and addressing forms (e.g., LDR/STR with base+offset). (Source URL: https://developer.arm.com/documentation) - ARM developer docs hub for instruction set and addressing mode specifications. ↩

  2. RISC-V Instruction Set Manual: Load/store instructions and base+offset addressing form (offset(rs1)). (Source URL: https://riscv.org/technical/specifications/) - Official RISC-V specification site describing load/store addressing semantics. ↩

Compute using retrieved values

Execute

If arithmetic uses that memory value, it proceeds after the load completes. "

Knowledge Check

Question 1 of 4
Q1Single choice

Which statement best describes a memory-reference operand?

Explore Related Topics

1

Branching Instructions in the 8051 Microcontroller

The 8051 microcontroller uses branching instructions to alter the sequential flow of a program by loading new addresses into the Program Counter, enabling loops, decisions, and sub‑routines.

  • Unconditional jumps (LJMP, AJMP, SJMP, indirect JMP @A+DPTR) differ in address range and size; SJMP/AJMP use 2 bytes versus 3 for LJMP.
  • Conditional jumps (JZ, JNZ, JC, JNC, JB, JNB) depend on accumulator or PSW flags; CJNE also sets the Carry flag for comparisons.
  • DJNZ decrements a register or memory location and loops while the result is non‑zero.
  • SJMP calculates its target by adding a signed 8‑bit offset to the PC after the 2‑byte instruction.
  • AJMP’s 2 KB page limitation requires careful placement to avoid crossing page boundaries.
2

Effective Address Calculation for `20(R1)` and `-(R2)` Addressing Modes

3

List Registers of a Non-Pipelined CPU and Their Purposes

Browse all research articles