Homework 4 Review: Pointers, Stack Frames, and Arguments

Why This Matters

Homework 4 connects C expressions to memory and ARM64 procedure calls. You explain which caller variables a function can change, count bytes in stack frames, and follow character pointers through argument strings. The coding portion then uses those string skills to interpret and validate decimal input.

Written Portion: A Copy of a Value or a Copy of an Address?

Core idea: C passes arguments by value. A function receives a copy of an integer or a copy of a pointer. Changing a copied integer leaves the caller's integer alone. Dereferencing a copied pointer can change the object whose address the caller supplied.

void changeCopy(int n) { n = 14; }
void changeObject(int *p) { *p = 14; }

int score = 6;
changeCopy(score);       // score remains 6
changeObject(&score);    // score becomes 14

Trace the Indices Before Naming a Loop

For a loop with index values 0, 2, 4 over {7, 1, -3, 8, 5}, a running total visits 7, -3, and 5: 0 → 7 → 4 → 9. The stride selects every second element starting at index zero. Name a function from its behavior, and name parameters from their roles: array, stride, and length tell you more than single letters.

The stride is in elements. C scales array[i] by the element size automatically. Do not multiply the index by 4 inside a C subscript just because an ARM64 integer load uses a byte address.

Written Portion: Allocated Bytes Are Not Always Used Bytes

A frame reserves space by moving sp toward lower addresses. Count the reservation separately from the distinct byte ranges occupied by saved values. On the course ARM64 system, an x register holds 8 bytes, a w register holds 4, and stack alignment is 16 bytes.

remember:
    sub sp, sp, 32
    str x0, [sp, 16]    // bytes 16–23: saved pointer
    str w1, [sp, 28]    // bytes 28–31: saved integer
    ldr w2, [sp, 28]    // reads the same slot
    add sp, sp, 32
    ret

Also recognize stack adjustment inside a memory instruction: str x30, [sp, -32]! lowers sp by 32 before storing the 8-byte return address. ldr x30, [sp], 32 loads from the current address, then raises sp by 32.

bl writes the return address into x30. A function that calls another function must preserve its own return address when needed, then restore it before ret. Passing the address of a local integer requires an x register for the address; accessing that integer uses a w register.

Reading the supplied listing: the Homework 4 stack example omits ret after increment restores sp. Its displayed frame sizes can still be counted, but executing it literally would fall through into the next function. The C behavior assumes that increment returns normally.

Written Portion: Trace Each Argument Pointer Independently

For ./trace sun fog, argc is 3: the program name counts too. argv[0] points to "./trace", argv[1] to "sun", and argv[2] to "fog". Each is a null-terminated string.

Copying an entry into char *p[3] copies an address, not the text. Advancing p[j] then changes that local pointer entry while argv[j] retains its original address. A three-entry local pointer array only has room for indices 0 through 2.

Round 0: '.' + 's' + 'f' → .sf
Round 1: '/' + 'u' + 'o' → /uo
Round 2: 't' + 'n' + 'g' → tng

When tracing the homework, use the actual program-name string from the command shown. Include it in the shortest-length calculation. Keep commented-out statements out of your trace, and distinguish printed output from the integer returned by main.

Coding Portion: Validate Text Before Doing Arithmetic

Create add.c in your Homework 4 directory. The program takes exactly two decimal arguments, each from 0 to 99. The assignment forbids atoi. The inputs arrive as strings, so adding their first character codes is not numeric addition.

1. Check the argument count before accessing argv[1] or argv[2]. Two supplied numbers require argc == 3.
2. Check each complete string against the assignment's one- or two-digit nonnegative decimal format. An empty string, a sign, letters, or an extra character does not meet that format.
3. Convert validated digits, then add the two integer values. Each input is at most 99, but their sum can be as large as 198.
4. Choose the required output message and include its final newline. Avoid extra prompts or debugging output.

The required formats are Usage: ./add <num1> <num2>, Error: INPUT is not a number from 0 to 99., and Do you know that A + B = SUM?, with placeholders replaced by the relevant input or numbers. Match the PDF's spelling, spaces, punctuation, and newline.

Testing on the course Linux VM:

make add
./add 42 7
./test_add.sh

The provided script builds the program and compares output against support/test_add, stopping at the first failure. That helper is an ARM64 Linux executable. Also check boundaries and malformed strings manually: 0, 99, too many arguments, too few arguments, an empty argument, and a string containing a nondigit. A script pass is evidence, not a substitute for understanding validation. Submit add.c to Gradescope as the assignment directs.

Common Mistakes

Quick Reference