3.2 Instruction formats and addressing modes

Instruction formats and addressing modes are key components of computer architecture. They define how CPUs interpret and execute instructions, determining the structure of machine code and how data is accessed.

Understanding these concepts is crucial for efficient programming and optimizing code performance. Different formats and modes offer various trade-offs between speed, memory usage, and flexibility, impacting overall system efficiency.

Instruction Formats and Components

Primary Instruction Formats

Top images from around the web for Primary Instruction Formats

• 

  Frontiers | Sepia, Tarsier, and Chameleon: A Modular C++ Framework for Event-Based Computer Vision View original

  Is this image relevant?

• 

  cpu architecture - RISC-V: Immediate Encoding Variants - Stack Overflow View original

  Is this image relevant?

• 

  File:Vextractf128.svg - Wikimedia Commons View original

  Is this image relevant?

• 

  Frontiers | Sepia, Tarsier, and Chameleon: A Modular C++ Framework for Event-Based Computer Vision View original

  Is this image relevant?

• 

  cpu architecture - RISC-V: Immediate Encoding Variants - Stack Overflow View original

  Is this image relevant?

1 of 3

Top images from around the web for Primary Instruction Formats

• 

  Frontiers | Sepia, Tarsier, and Chameleon: A Modular C++ Framework for Event-Based Computer Vision View original

  Is this image relevant?

• 

  cpu architecture - RISC-V: Immediate Encoding Variants - Stack Overflow View original

  Is this image relevant?

• 

  File:Vextractf128.svg - Wikimedia Commons View original

  Is this image relevant?

• 

  Frontiers | Sepia, Tarsier, and Chameleon: A Modular C++ Framework for Event-Based Computer Vision View original

  Is this image relevant?

• 

  cpu architecture - RISC-V: Immediate Encoding Variants - Stack Overflow View original

  Is this image relevant?

1 of 3

• The three primary instruction formats are register-to-register, register-to-memory, and memory-to-memory
• Register-to-register instructions perform operations using data stored in registers, with the result stored back in a register (addition, subtraction)
• Register-to-memory instructions use data from both registers and memory, with the result typically stored in a register or memory location (load, store)
• Memory-to-memory instructions operate on data stored in memory locations, with the result stored back in memory
  • These instructions are less common and may not be supported by all architectures due to potential performance issues

Components of Instruction Formats

• Instruction formats typically include fields for the opcode (operation code), source operand(s), and destination operand(s)
• The opcode field specifies the operation to be performed, such as addition, subtraction, or data movement (ADD, SUB, MOV)
• Source operand fields indicate the registers or memory locations containing the input data for the operation
  • These fields can reference registers directly or use addressing modes to access memory
• Destination operand fields specify the register or memory location where the result of the operation will be stored
  • The destination can be a register or a memory location, depending on the instruction format and the specific operation being performed
• Additional fields may be present in instruction formats, such as immediate values, addressing mode specifiers, or condition codes

Addressing Modes: Purpose and Functionality

Addressing Mode Overview

• Addressing modes determine how the CPU interprets and accesses operands in instructions
• They provide flexibility in accessing data from various sources, such as registers, memory, or immediate values
• Different addressing modes allow for efficient access to data based on the specific requirements of the program
• Addressing modes can be classified into several categories, each with its own purpose and functionality

Common Addressing Modes

• Immediate addressing uses a constant value as the operand, which is directly specified in the instruction
  • This mode is useful for providing fixed values or constants to instructions (ADD R1, #10)
• Register addressing uses the contents of a register as the operand
  • It provides fast access to frequently used data stored in registers (MOV R2, R1)
• Direct addressing uses the memory address of the operand, which is directly specified in the instruction
  • This mode is used when the memory address of the operand is known and remains constant (LOAD R1, [0x1000])
• Indirect addressing uses a register or memory location that contains the address of the operand
  • It allows for dynamic access to data whose address may change during program execution (LOAD R1, [R2])
• Indexed addressing combines a base address with an offset or index to calculate the effective address of the operand
  • This mode is useful for accessing elements in arrays or data structures (LOAD R1, [R2 + R3])
• Base-plus-offset addressing adds a base address and an offset to determine the effective address of the operand
  • It is commonly used for accessing data in structures or records (LOAD R1, [R2 + 0x10])
• PC-relative addressing calculates the operand address relative to the current program counter (PC) value
  • This mode is used for position-independent code or for accessing data relative to the current instruction (LOAD R1, [PC + 0x20])
• Autoincrement and autodecrement addressing modes automatically modify the address register after accessing the operand
  • These modes are useful for iterating through data structures or implementing stack operations (PUSH [R1+], POP [R2-])

Instruction Formats vs Addressing Modes in Programming

Selecting Appropriate Instruction Formats

• Select the appropriate instruction format based on the required operation and data locations (registers or memory)
• Use register-to-register instructions for operations involving data stored in registers, such as arithmetic or logical operations (ADD R1, R2, R3)
• Employ register-to-memory instructions when data needs to be transferred between registers and memory or when one operand is in memory (LOAD R1, [R2])
• Utilize memory-to-memory instructions sparingly, as they are less efficient and not supported by all architectures
  • If memory-to-memory operations are required, consider breaking them down into separate load and store instructions

Applying Appropriate Addressing Modes

• Choose the appropriate addressing mode based on the location and accessibility of the operands
• Apply immediate addressing for constants or known values that do not change during program execution (MOV R1, #100)
• Use register addressing for fast access to frequently used data stored in registers (ADD R1, R2)
• Employ direct addressing when the memory address of the operand is known and remains constant (LOAD R1, [0x2000])
• Apply indirect addressing when the operand address is stored in a register or memory location and may change during program execution (LOAD R1, [R2])
• Utilize indexed addressing for accessing elements in arrays or data structures using a base address and an offset (LOAD R1, [R2 + R3])
• Use base-plus-offset addressing for accessing data in structures or records where the base address represents the start of the structure (LOAD R1, [R2 + 0x20])
• Apply PC-relative addressing for position-independent code or for accessing data relative to the current instruction (LOAD R1, [PC + 0x30])
• Employ autoincrement and autodecrement addressing modes for iterating through data structures or implementing stack operations (PUSH [R1+], POP [R2-])

Optimizing Code with Instruction Formats and Addressing Modes

• Consider the trade-offs between code size, performance, and memory usage when selecting instruction formats and addressing modes
• Use register-to-register instructions whenever possible to minimize memory accesses and improve performance
• Optimize memory accesses by using appropriate addressing modes and minimizing the number of memory operations
• Utilize immediate values and constants when they are known at compile-time to reduce runtime overhead
• Employ indexed and base-plus-offset addressing modes for efficient access to arrays and structures
• Use autoincrement and autodecrement addressing modes for iterative operations on data structures to reduce code size and improve efficiency