Enough C and assembly to follow a compare and a jump

02Where a compare lives

In compare.c, if (x == 7) selects the block returning 1 when the equality is true. Otherwise execution reaches return 0. These integers are the function's chosen results; a return value of 0 is not universally a failure. Trace the source rule before trying to name a processor instruction.

A conditional jump is an instruction that may move execution to another location depending on a condition. A register is a small processor storage location, and an address identifies a location in memory. The conceptual branch card names no real registers, opcodes or addresses. An opcode encodes an instruction; none was captured here.

A recorded link attempt failed because this function-only source has no main. That record is separate from the unrun -O0 -g candidate instruction. There is no matched executable or disassembly for this lesson. A source prediction does not establish what a particular compiled binary contains.

1/* Original teaching source. Not compiled. */
2int mark(int x) {
3    if (x == 7) {
4        return 1;
5    }
6    return 0;
7}

1/* Original teaching source. Not compiled. */
2int mark(int x) {
3    if (x == 7) {
4        return 1;
5    }
6    return 0;
7}

03Compilation primer

A C build can preprocess source, compile it, assemble the resulting instructions and link object files into an executable. Linking combines compiled pieces with required support code. Function-only sources can be compiled as components, but cannot become the intended standalone hosted program without an entry function and appropriate linking.

The printed command gcc -O0 -g -o mark compare.c is an unrun historical candidate, not a complete working build recipe for this function-only file. -O0 disables most optimization passes, -g requests debugger information and -o names the output. These flags neither add main nor guarantee an instruction sequence. Do not run the candidate to finish this text activity.

/* Original teaching source. Not compiled. */
int mark(int x) {
    if (x == 7) {
        return 1;
    }
    return 0;
}

Historical/candidate build record for compare.c. This file contains a function without main.

Historical QA, 2026-10-12: gcc13.3.0 with gcc -Wall -Wextra -o prog compare.c failed to link because main was undefined. No executable, object file or assembly listing was retained.

Unrun historical candidate, not a working standalone build recipe:
gcc -O0 -g -o mark compare.c

-O0 disables most optimization passes; it does not guarantee one instruction listing.
-g requests debugger information; -o mark names the output.
These options do not supply main. Do not run this command for the lesson.
A later component build or harness would need its own explicit design and evidence record.

Conceptual instruction model. Not compiler output. Not a disassembly.

Decision: compare the function's integer with the number in the condition.
If the comparison says equal, take the path that returns the equal-path value.
If the comparison says not equal, take the other path.

No address, opcode, or register was captured.
A later owned build can replace this card with a disassembly from that build.
Until then, this card is only a picture of the decision.

04Trace lane

Use the separate lane function to practice the same source-tracing method with different values. A function call such as lane(5) supplies 5 as n. Record the condition, whether it is true and which return is reached. The conceptual model remains separate from a real disassembly.

/* Activity source. Different numbers from the question. Not compiled. */
int lane(int n) {
    if (n == 5) {
        return 2;
    }
    return 6;
}

1. Read lane. Write the condition and both return values in your notes.
2. Trace n equal to 5. Check: the condition is true, so the source trace returns 2.
3. Trace n equal to 1. Check: the condition is false, so the source trace returns 6.
4. Stop. Do not run gcc. A captured disassembly is still missing, and the model does not fill that gap.

05Optional challenge

Point at the not-equal path in the conceptual model and write the lane source line it corresponds to when n is 1. About ten minutes. There is still no recorded branch instruction to match.

06Fresh cases for the checks

Use these fictional cases for the checks below. They have different inputs from the worked examples. Read them here or make notes; no installation or external service is needed.

int twig(int n) {
  if (n == 9) { return 4; }
  return 8;
}
Conceptual model: compare n with 9; equal takes path E; not-equal takes path N.
Paths model the source. No instructions or run were captured.

07Explain your evidence

Optional written self-check: explain one decision using the supplied case. No tool run is required.

Check your explanation: substitute the input; state the equality result, selected branch and reached return; distinguish a source prediction from compiled instructions and an observed run.