Computer Hardware (5) - Assembly Language and MIPS

Flashcards covering introductory assembly language concepts, MIPS architecture, memory organization, and the SPIM simulator based on Lecture 10 notes.

System Software

Acts as a bridge between hardware and user programs to make a computer usable by managing memory, I/O operations, and program loading.

Operating System (OS)

A set of programs providing an interface between the user and hardware that hides hardware complexities and manages data, programs, and resources efficiently.

High-Level Programming Languages

Languages like Python, Java, and C++ designed for human readability that abstract away machine-specific details to focus on problem-solving.

Low-Level Programming Languages

Languages closer to machine language, such as Assembly, that provide more control over hardware and are used for system programming.

Machine Level (Machine Code)

The lowest level of code execution consisting of binary instructions that a computer's CPU can execute directly.

Bytecode

An intermediary form of code, such as those produced by a Java compiler ($.class$ files), that needs further interpretation or just-in-time compilation.

Assembly Language

A low-level language providing precise control over execution, efficient memory usage, and direct access to CPU registers and memory.

Assembler

A translator that converts human-readable assembly language into raw machine instructions using a one-to-one mapping.

RISC (Reduced Instruction Set Computer)

A design philosophy from the early 1980s that focuses on speeding up the most simple and commonly used instructions for faster execution.

CISC (Complex Instruction Set Computer)

A computer design that supports many complex instructions to reduce instructions per program, often at the cost of slower execution for simple instructions.

MIPS (Microprocessor without Interlocking Pipeline Stages)

A RISC-based processor designed by John Hennessy in 1981, widely used in embedded systems like automotive computers.

Segmentation

The practice of keeping instructions and data in separate sections of memory to prevent the computer from executing data or mistaking instructions.

Text Segment

The section of MIPS memory starting at $0x400000$ that stores the program's instructions (code).

Data Segment

The section of MIPS memory starting at $0x10000000$ that holds static/global variables and dynamically allocated memory (heap).

Stack Segment

The section of MIPS memory starting near $0x7fffffff$ that grows downward; used for function calls and local variables.

Program Counter (PC)

A register that points to the memory address of the next instruction to be executed.

Floating-Point Registers

A set of 16 registers ($f0$ - $f15$) used to store floating-point values like $3.459 \times 10^9$ for numerical computations.

$zero

MIPS register number 0, which always holds the constant value 0.

$v0-$v1

MIPS registers 2-3 used for returning values from functions.

$a0-$a3

MIPS registers 4-7 used for passing arguments.

$sp

The MIPS stack pointer register, numbered as register 29.

SPIM

A software tool that simulates a MIPS R2000/R3000 RISC processor environment to assemble, run, and debug MIPS programs.

syscall

A specific MIPS instruction used to request operating system services from the Kernel, such as I/O operations.

Mnemonics

Symbolic names for machine instructions, such as MOV, ADD, la (load address), and li (load immediate).

Assembler Directive

Commands for the assembler that are not translated into machine code, such as .data or .text to define memory segments.

Pseudo-Instructions

Instructions like la or li that do not correspond to a single machine instruction but are translated by the assembler into a sequence of machine instructions.

Immediate Value

A numerical constant that is embedded directly within a machine instruction rather than being fetched from memory.

Breakpoint

A predefined line in the code where program execution pauses to allow examination of the machine state, such as registers and memory.

lw (load word)

An instruction that loads a 4-byte word from a memory address into a register.

sw (store word)

An instruction that stores a 4-byte word from a register into a memory address.