MIPS-32 Instruction Set Architecture Quiz

MIPS-32 Instruction Set Architecture (ISA)

• Is a common computer architecture
• Primarily uses 32-bit instructions and data, including addresses
• Represents integers as signed and unsigned values
• Implements floating-point numbers based on the IEEE 754 standard, using:
  • Single precision (32-bit): 8-bit exponent, 23-bit significand
  • Double precision (64-bit): 11-bit exponent, 52-bit significand

MIPS-32 ISA Categorization

• Instructions are categorized based on their function
  • Computational: Performing arithmetic and logical operations
  • Load/Store: Accessing data from and to memory
  • Jump and Branch: Controlling program flow through jumps and conditional branches
  • Floating Point: Handling floating-point operations
  • Memory Management: Managing memory access and allocation
  • Special: Performing system-specific or specialized operations

MIPS-32 Instruction Formats

• MIPS uses three distinct instruction formats:
  • R-type (Register type): Operates on 3 registers
    • Utilizes a format with 6 fields for various parts of the instruction
    • Each field has a specific bit-width: opcode (6 bits), rs (5 bits), rt (5 bits), rd (5 bits), shamt (5 bits), funct (6 bits)
  • I-type (Immediate type): Operates on 2 registers and a 16-bit immediate value
    • Utilizes a format with 4 fields: opcode (6 bits), rs (5 bits), rt (5 bits), immediate (16 bits)
  • J-type (Jump type): Utilizes a 26-bit immediate value for jump targets
    • Utilizes a format with 2 fields: opcode (6 bits), immediate (26 bits)

MIPS Design Principles

• MIPS architecture emphasizes simplicity, speed, and efficiency, driven by key design principles:
  • Simplicity Favors Regularity:
    • Fixed-size instructions
    • Limited number of instruction formats, with opcode always the first 6 bits
  • Smaller is Faster:
    • Limited instruction set
    • Limited number of registers in the register file (32)
    • Limited number of addressing modes
  • Make the Common Case Fast:
    • Arithmetic operands fetched directly from the register file
    • Support for immediate operands

MIPS Arithmetic Instructions

• Arithmetic operations in MIPS are primarily based on addition and subtraction, with a consistent format:
  • add: Performs addition (e.g., add a, b, c sets a = b + c).
  • sub: Performs subtraction (e.g., sub a, b, c sets a = b - c).
• This consistent format promotes simplicity and efficient implementation.

MIPS Register File

• MIPS employs a 32 x 32-bit register file, intended for storing frequently accessed data.
• The registers are numbered from 0 to 31 and hold 32-bit values – known as "words".
• Different registers have specific names:
  • t0−t0 - t0−t9: Temporary values
  • s0−s0 - s0−s7: Saved variables

MIPS Memory Access

• Main memory is crucial for storing larger data structures, such as arrays, structures, and dynamic data.
• Memory access is implemented using:
  • lw (load word): Loads a 32-bit word from memory into a register.
  • sw (store word): Stores a 32-bit word from a register into memory.
• MIPS uses a byte-addressable memory model, with every byte having a unique address.
• Memory is organized in words, each occupying 4 bytes, and requiring alignment on 4-byte boundaries (address must be a multiple of 4).
• MIPS is a Big Endian system, meaning that the most significant byte of a word has the lowest address.

Big Endian vs. Little Endian

• In a byte-addressable machine, a 32-bit integer (4 bytes) can be stored in two ways:
  • Big Endian: The most significant byte (MSB) gets the lowest address.
  • Little Endian: The least significant byte (LSB) gets the lowest address.

MIPS Memory Operand Example

• C code: g = h + A;
  • Assume: g in $s1, h in $s2, base address of array A in $s3
• Compiled MIPS code:
  • lw $t0, 32($s3): Loads the value located 32 bytes (4 bytes per word * 8) from the array A into register $t0.
  • add $s1, $s2, $t0: Adds the value in $s2 (h) to the value in $t0 (loaded value from array) and stores the result in $s1 (g).
• This shows how MIPS memory access is accomplished through instructions like lw for fetching data and sw for storing data.

Test your knowledge of the MIPS-32 Instruction Set Architecture, which is widely used in computer architecture. This quiz covers various aspects such as instruction formats, types of instructions, and the representation of floating-point numbers. Challenge yourself to understand the details of this important architecture!