Stanford CS107 - Computer Organization & Systems: Assembly, Memory & C Execution Model Flashcards

Question 1

What is x86-64 assembly language?

Accepted Answer

x86-64 assembly is a low-level programming language that directly interacts with the CPU's instruction set for 64-bit Intel/AMD processors. It provides fine-grained control over hardware, memory, and registers, often used for performance-critical code or operating system development.

Question 2

Identify the primary general-purpose registers in x86-64 and their common uses.

Accepted Answer

Key registers include:
*   `RAX`: Accumulator, often used for return values.
*   `RBX`: Base register, general purpose.
*   `RCX`: Counter, often used for loop counts.
*   `RDX`: Data register, general purpose.
*   `RSI`: Source index, often points to source data for string operations.
*   `RDI`: Destination index, often points to destination data for string operations.
*   `RBP`: Base pointer, typically points to the base of the current stack frame.
*   `RSP`: Stack pointer, points to the top of the stack.
*   `R8`-`R15`: General-purpose registers, often used for additional function arguments.

Question 3

Explain the purpose of the `mov` instruction in x86-64 assembly.

Accepted Answer

The `mov` instruction (move) copies data from a source operand to a destination operand. It can move data between registers, from an immediate value to a register/memory, or between a register and memory. Example: `mov rax, rbx` (copies content of `rbx` to `rax`).

Question 4

Describe the typical memory layout of a C program.

Accepted Answer

A C program's memory is typically divided into several segments:
1.  **Text Segment**: Contains the executable machine code.
2.  **Data Segment**: Stores initialized global and static variables.
3.  **BSS Segment**: Stores uninitialized global and static variables (zero-initialized by OS).
4.  **Heap Segment**: Used for dynamic memory allocation (e.g., `malloc`, `calloc`). Grows upwards.
5.  **Stack Segment**: Used for local variables, function arguments, and return addresses. Grows downwards.

Question 5

What is the Heap segment used for, and how does it grow?

Accepted Answer

The Heap segment is used for dynamic memory allocation, where memory is requested and released by the program during runtime using functions like `malloc`, `calloc`, and `realloc`. It typically grows upwards in memory addresses, towards the stack segment.

Question 6

What is the Stack segment used for, and how does it grow?

Accepted Answer

The Stack segment is used for automatic memory allocation, primarily for local variables, function arguments, and storing return addresses during function calls. It operates as a LIFO (Last-In, First-Out) structure and typically grows downwards in memory addresses, towards the heap segment.

Question 7

Define a C pointer and explain the `&` (address-of) operator.

Accepted Answer

A C pointer is a variable that stores the memory address of another variable. The `&` (address-of) operator is used to retrieve the memory address of a variable. For example, `int x = 10; int *ptr = &x;` assigns the address of `x` to `ptr`.

Question 8

Explain the `*` (dereference) operator in C.

Accepted Answer

The `*` (dereference) operator is used to access the value stored at the memory address pointed to by a pointer. If `int *ptr` holds the address of an integer, then `*ptr` gives you the integer value itself. Example: `int x = 10; int *ptr = &x; printf("%d", *ptr);` would print `10`.

Question 9

How does pointer arithmetic work in C?

Accepted Answer

Pointer arithmetic in C is scaled by the size of the data type the pointer points to. If `ptr` points to an `int` (typically 4 bytes), then `ptr + 1` does not add 1 byte to the address, but rather `1 * sizeof(int)` bytes. This ensures `ptr + 1` points to the *next* element of that type in memory. Example: `char *c_ptr; c_ptr + 1` adds 1 byte. `int *i_ptr; i_ptr + 1` adds 4 bytes (on most systems).

Question 10

What is memory alignment, and why is it important?

Accepted Answer

Memory alignment refers to placing data at memory addresses that are multiples of the data's size (or a power of 2). For example, a 4-byte integer might be aligned to an address that is a multiple of 4. It's important because:
1.  **Performance**: CPUs often fetch data in blocks; aligned data can be accessed in a single memory operation, while unaligned data might require multiple, slower operations.
2.  **Hardware Requirements**: Some hardware architectures require data to be aligned, or they will throw an error.

Question 11

Explain the purpose of `malloc()` in C.

Accepted Answer

`malloc()` (memory allocate) is a standard library function in C used for dynamic memory allocation. It requests a block of memory of a specified size (in bytes) from the heap. If successful, it returns a `void*` pointer to the beginning of the allocated block; otherwise, it returns `NULL`.

Question 12

Explain the purpose of `free()` in C.

Accepted Answer

`free()` is a standard library function in C used to deallocate a block of memory previously allocated by `malloc()`, `calloc()`, or `realloc()`. It returns the memory to the heap, making it available for future allocations. Failing to `free()` allocated memory leads to memory leaks.

Question 13

What is a memory leak, and how can it be prevented?

Accepted Answer

A memory leak occurs when a program allocates memory dynamically (e.g., using `malloc`) but fails to deallocate it using `free()` when it's no longer needed. This leads to a gradual consumption of available memory, potentially causing the program or system to run out of memory. Prevention involves ensuring every `malloc()` call has a corresponding `free()` call when the memory is no longer required, especially in error handling paths or loops.

Question 14

How do bitwise AND (`&`) and OR (`|`) operators work?

Accepted Answer

Bitwise operators perform operations on individual bits of their operands:
*   **AND (`&`)**: Sets a bit to 1 if *both* corresponding bits are 1; otherwise, it's 0. Useful for clearing bits or checking if a bit is set.
*   **OR (`|`)**: Sets a bit to 1 if *at least one* of the corresponding bits is 1; otherwise, it's 0. Useful for setting bits.

Question 15

How do bitwise XOR (`^`) and NOT (`~`) operators work?

Accepted Answer

*   **XOR (`^`)**: Sets a bit to 1 if the corresponding bits are *different*; otherwise, it's 0. Useful for toggling bits or swapping values without a temporary variable.
*   **NOT (`~`)**: Inverts all bits of its operand (0 becomes 1, 1 becomes 0). This is a unary operator.

Question 16

How can you use a bitmask to set a specific bit in an integer?

Accepted Answer

To set the $N^{th}$ bit (0-indexed) in an integer `x`, you can use the bitwise OR operator (`|`) with a mask created by left-shifting 1 by $N$ positions: `x = x | (1 << N);` or `x |= (1 << N);`. Example: To set the 3rd bit (value 8) in `x`, use `x |= (1 << 3);`.

Question 17

How can you use a bitmask to clear a specific bit in an integer?

Accepted Answer

To clear the $N^{th}$ bit (0-indexed) in an integer `x`, you can use the bitwise AND operator (`&`) with a mask created by inverting (`~`) a left-shifted 1: `x = x & ~(1 << N);` or `x &= ~(1 << N);`. Example: To clear the 3rd bit in `x`, use `x &= ~(1 << 3);`.

Question 18

What is a stack frame, and what are its typical components?

Accepted Answer

A stack frame (or activation record) is a region of the stack memory allocated for a function call. It contains:
*   **Return Address**: The address in the calling function to return to.
*   **Saved `RBP`**: The base pointer of the *caller's* stack frame.
*   **Function Arguments**: Parameters passed to the function.
*   **Local Variables**: Variables declared within the function.
*   **Saved Registers**: Any registers the function needs to preserve for the caller.

Question 19

Explain the roles of `RBP` and `RSP` in managing stack frames.

Accepted Answer

*   `RBP` (Base Pointer): Points to a fixed location within the current stack frame, typically the saved `RBP` of the caller. It provides a stable reference point for accessing local variables and arguments relative to the frame's base.
*   `RSP` (Stack Pointer): Points to the *top* (lowest address) of the current stack. It changes as data is pushed onto or popped from the stack. `RSP` defines the current boundary of the stack.

Question 20

Describe the basic steps for a function call in x86-64 assembly.

Accepted Answer

1.  **Argument Passing**: Arguments are passed in registers (`RDI`, `RSI`, `RDX`, `RCX`, `R8`, `R9`) or on the stack if more are needed.
2.  **`call` instruction**: Pushes the return address onto the stack and jumps to the function's entry point.
3.  **Prologue**: Inside the function, `push rbp` saves the caller's base pointer, then `mov rbp, rsp` sets `rbp` to the current `rsp`. Space for local variables is allocated by decrementing `rsp`.
4.  **Function Body**: Executes the function's logic.
5.  **Epilogue**: `leave` (equivalent to `mov rsp, rbp` then `pop rbp`) restores `rsp` and `rbp`. `ret` pops the return address from the stack and jumps back to the caller.

Question 21

What is the primary mechanism a heap allocator uses to manage free memory blocks?

Accepted Answer

A common mechanism is a **free list**. When memory is freed, the allocator adds the freed block to a list of available blocks. When a `malloc` request comes in, the allocator searches this list for a block large enough to satisfy the request. If found, it might split the block (returning the requested portion and adding the remainder back to the free list) or return the entire block.

Question 22

What is 'use-after-free' and why is it a security vulnerability?

Accepted Answer

Use-after-free occurs when a program attempts to access memory that has already been freed. After `free()` is called, the memory block might be reallocated for a different purpose. If the original pointer is still used, it could read/write to unintended data, leading to data corruption, crashes, or even arbitrary code execution if an attacker can control the reallocated content.

Question 23

What is a 'double free' error and its potential consequences?

Accepted Answer

A double free error occurs when a program attempts to `free()` the same block of memory twice. This can corrupt the heap's internal data structures (e.g., the free list), leading to unpredictable behavior, crashes, or even security vulnerabilities like arbitrary memory writes, which an attacker could exploit.

Question 24

How are function arguments typically passed in x86-64 Linux calling convention (System V ABI)?

Accepted Answer

For integer and pointer arguments, the first six arguments are passed in specific registers: `RDI`, `RSI`, `RDX`, `RCX`, `R8`, and `R9`. If there are more than six arguments, the additional arguments are pushed onto the stack in reverse order (right-to-left) before the `call` instruction.

Question 25

What is the purpose of the `leave` instruction in x86-64 assembly?

Accepted Answer

The `leave` instruction is used in a function's epilogue to dismantle the stack frame. It is equivalent to executing `mov rsp, rbp` (restoring the stack pointer to the base of the frame) followed by `pop rbp` (restoring the caller's base pointer). This prepares the stack for the `ret` instruction.

Stanford CS107 - Computer Organization & Systems: Assembly, Memory & C Execution Model

Cards in this deck

Related Flashcard Sets

TypeScript - Advanced Type Systems, Generics & Design Patterns

Harvard ECON1011 - Intermediate Microeconomics: Game Theory & Market Structures

MIT 18.03 - Differential Equations: Ordinary Differential Equations, Laplace & Fourier

CPA Exam FAR - Financial Accounting & Reporting: US GAAP & Revenue Recognition