Stanford CS107 - Computer Organization & Systems: C Memory & Assembly

1. Text: Read-only binary instructions (%rip).
2. Data: Global and static variables (initialized and uninitialized bss).
3. Heap: Dynamically allocated memory managed via malloc/free (grows upward to higher addresses).
4. Stack: Function frames, local variables, and saved registers (grows downward to lower addresses).

1. Caller: Passes first 6 arguments in registers (%rdi, %rsi, %rdx, %rcx, %r8, %r9), pushes extra args onto stack.
2. Caller: Executes call, which pushes return address (%rip) and jumps to target.
3. Callee: Allocates stack space by decrementing %rsp and saves callee-saved registers.
4. Callee: Executes body, sets return value in %rax.
5. Callee: Restores registers, increments %rsp, runs ret (pops return address into %rip).

In order:
1. %rdi (1st argument)
2. %rsi (2nd argument)
3. %rdx (3rd argument)
4. %rcx (4th argument)
5. %r8 (5th argument)
6. %r9 (6th argument)

Any additional arguments (7+) are pushed onto the stack in reverse order.

In C, adding integer $i$ to pointer $p$ scales the offset by the byte size of underlying data type $T$:
$$\text{Address}(p+i)=\text{Address}(p)+(i\times \text{sizeof}(T))$$
For example, if int *p = 0x1000, p + 2 evaluates to $0x1000+(2\times 4)=0x1008$.

Hardware fetches memory efficiently when data of size $K$ bytes resides at an address divisible by $K$ (e.g., 4-byte int aligned at address $0(\mathrm{mod}4)$).

C compilers automatically insert padding bytes inside structs so that every field meets its alignment rule, and pads the overall struct size to a multiple of its largest field's alignment requirement.

A void* is a generic pointer to an unknown byte type, making sizeof(void) undefined in standard C. Because pointer arithmetic requires scaling steps by size $\text{sizeof}(T)$, void* must be explicitly cast (e.g., to char* for byte-level offset scaling) before arithmetic operations.