Build Systems & Toolchain

Question 1 (10 marks)

(a) (4 — 1 per stage)

Why: each stage transforms one representation to the next lower level.

(b) (4)

• #include is expanded during preprocessing (2) — it is a textual substitution done by cpp before any C is compiled.
• The address of printf is fixed during linking (2) — printf lives in libc; the compiler only emits an unresolved symbol reference / relocation entry, and only the linker (or dynamic loader) knows the final address. They differ because header expansion is purely textual, while address assignment requires knowing where all object code lands in memory.

(c) (2) — -S stops after assembly file; -c stops after object file. (1 each)

Question 2 (12 marks)

(a) (3) The linker processes inputs left to right in one pass. It maintains a set of currently-unresolved (undefined) symbols. When it reaches an archive, it pulls in only those member .o files that satisfy a currently pending undefined symbol; it does not revisit an archive later. Objects listed on the command line are always fully included.

(b) (4) Command (B) fails. When -lutil is seen first, the pending-undefined set is empty (no helper reference has appeared yet, because app.o comes later), so the linker pulls nothing from libutil.a and discards it. When app.o is then processed, helper becomes undefined but the archive has already been passed → undefined reference to helper. (2 for identifying B, 2 for the empty-pending-set reasoning.)

(c) (3)

gcc app.o -L. -lutil -lm

app.o first registers helper and sin as undefined; -lutil then resolves helper, -lm resolves sin. Libraries must come after the objects that use them so the referencing symbols are already pending. (2 command, 1 explanation.)

(d) (2)

• Runtime: static → code is copied into the executable, no library needed at run time; shared → the .so must be present and loaded by the dynamic linker at run time. (1)
• Distribution: static → larger self-contained binary, no external dependency; shared → smaller binary but you must ship/have the .so, and can update it independently. (1)

Question 3 (12 marks)

CC = gcc
CFLAGS = -Wall -Wextra -O2
OBJS = main.o parse.o eval.o
 
all: calc                          # default target (1)
 
calc: $(OBJS)                      # link
	$(CC) $(CFLAGS) $^ -o $@       # $^ = all prereqs, $@ = target (3)
 
%.o: %.c                           # pattern rule (2)
	$(CC) $(CFLAGS) -c $< -o $@    # $< = first prereq, $@ = target (2)
 
$(OBJS): defs.h                    # header dependency (2)
 
.PHONY: all clean                  # (1)
clean:
	rm -f $(OBJS) calc             # (1)

Mark breakdown: pattern rule + $</$@ (4); link with $^ (3); .PHONY all+clean (3); defs.h dependency (2).

Question 4 (10 marks)

(a) (6)

cmake_minimum_required(VERSION 3.10)   # (1)
project(demo C)                        # (1)
add_library(mathx STATIC mathx.c)      # (2)
add_executable(app main.c)             # (1)
target_link_libraries(app PRIVATE mathx)  # (1)

(b) (3 — 1 each)

• Debug: -O0 -g (no optimization, full debug info).
• Release: -O3 -DNDEBUG (max optimization, asserts off, no debug info).
• RelWithDebInfo: -O2 -g -DNDEBUG (optimized but with debug symbols).

(c) (1)

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release

(then cmake --build build).

Question 5 (10 marks)

(a) (4) AddressSanitizer (ASan). Flags: -fsanitize=address -g (also link with it). It works at runtime because the out-of-bounds index may be computed dynamically; ASan instruments memory with redzones/shadow memory around allocations and checks each access at execution time — a compiler cannot in general prove the index is out of range statically. (1 name, 1 flag, 2 reasoning.)

(b) (3) (i) data race → TSan; (ii) signed integer overflow → UBSan; (iii) heap-buffer-overflow → ASan. (1 each.)

(c) (3)

watch counter        # stops when value changes (2)
backtrace   (or bt)  # print call stack (1)

Question 6 (6 marks)

(a) (2)

objdump -S a.out      # -S = disassemble with source interleaved (needs -g)

(Accept objdump -d for plain disassembly but full marks require -S.)

(b) (4) PIC = Position-Independent Code (1). Shared libraries can be loaded at different virtual addresses in different processes, so their code must not contain hard-coded absolute addresses; PIC uses relative addressing (via the GOT/PLT) so the same .so mapping works regardless of load address, allowing it to be shared across processes (2). Flag: -fPIC (1).

[
  {"claim":"Q1c: -S stops after assembly (.s), -c stops after object (.o) — distinct flags",
   "code":"S_flag='.s'; c_flag='.o'; result = (S_flag=='.s' and c_flag=='.o' and S_flag!=c_flag)"},
  {"claim":"Q2b: link fails when archive precedes referencing object (empty pending set)",
   "code":"def links(order):\n    pending=set()\n    for tok in order:\n        if tok=='app.o': pending|={'helper','sin'}\n        elif tok=='-lutil':\n            if 'helper' in pending: pending.discard('helper')\n        elif tok=='-lm':\n            if 'sin' in pending: pending.discard('sin')\n    return len(pending)==0\nB=links(['-lutil','app.o','-lm'])\nC=links(['app.o','-lutil','-lm'])\nresult = (B==False and C==True)"},
  {"claim":"Q1a: four canonical compilation stages",
   "code":"stages=['preprocess','compile','assemble','link']; result = len(stages)==4"},
  {"claim":"Q4b: build type flag mapping distinct optimization levels",
   "code":"bt={'Debug':'-O0','Release':'-O3','RelWithDebInfo':'-O2'}; result = len(set(bt.values()))==3 and bt['Debug']=='-O0'"}
]