From 84b3bdda52188a2e2eb1a621c79c1a7381778534 Mon Sep 17 00:00:00 2001
From: Christopher Haster <geky@geky.net>
Date: Wed, 16 Apr 2025 04:50:51 -0500
Subject: [PATCH] make: Adopted script changes in the Makefile

Mainly adopting the added flexibility in csv.py, also adding make
codemap-svg and friends for code map generation:

- Split result commands into separate result, result-csv, and
  result-diff commands so csv generation is explicit.

  So make result no longer implicitly overwrites csv files:

    make code
    make code-csv  -.
    make code       |
    make code-diff <'

  This gives more control over result diffing.

  make code-csv _is_ more or less just a dependency on the lfs.code.csv
  rule, but it avoids BUILDDIR mess and is easier to remember.

- Added make codemap/stackmap/ctxmap for in-terminal code/stack/ctx
  ascii art.

  I was a bit on the fence on these, since the result is more pretty
  than useful, but eh, can always drop them in the future.

- Added make codemap-svg/codemap-tiny-svg for generating interactive
  codemap svgs.

  This raised an interesting question if the make commands should
  generate light or dark mode svgs. I settled on dark mode since that's
  what I personally find the most useful.

  I think the way this will breakdown is with dark mode generally used
  for development, and light mode generally used for published material.
  And it's not too hard to run the script outside of the Makefile for
  publishing. Or override CODEMAPFLAGS.

- Adopted implicit prefixing, -q, etc. This simplifies some of the more
  complicated csv.py invocations (make summary, make funcs, etc).

See make help for a full list of commands.
---
 Makefile | 319 +++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 205 insertions(+), 114 deletions(-)

diff --git a/Makefile b/Makefile
index 86526912..6cc5e793 100644
--- a/Makefile
+++ b/Makefile
@@ -133,20 +133,20 @@ BENCHFLAGS += -b
 TESTFLAGS  += $(filter -j%,$(MAKEFLAGS))
 BENCHFLAGS += $(filter -j%,$(MAKEFLAGS))
 ifdef PERFGEN
-TESTFLAGS  += -p $(TEST_PERF)
-BENCHFLAGS += -p $(BENCH_PERF)
+TESTFLAGS  += -p$(TEST_PERF)
+BENCHFLAGS += -p$(BENCH_PERF)
 endif
 ifdef PERFBDGEN
-TESTFLAGS += -t $(TEST_TRACE) --trace-backtrace --trace-freq=100
+TESTFLAGS += -t$(TEST_TRACE) --trace-backtrace --trace-freq=100
 endif
 ifdef PERFBDGEN
-BENCHFLAGS += -t $(BENCH_TRACE) --trace-backtrace --trace-freq=100
+BENCHFLAGS += -t$(BENCH_TRACE) --trace-backtrace --trace-freq=100
 endif
 ifdef TESTMARKS
-TESTFLAGS += -o $(TEST_CSV)
+TESTFLAGS += -o$(TEST_CSV)
 endif
 ifdef BENCHMARKS
-BENCHFLAGS += -o $(BENCH_CSV)
+BENCHFLAGS += -o$(BENCH_CSV)
 endif
 ifdef VERBOSE
 TESTFLAGS   += -v
@@ -182,7 +182,7 @@ all build: $(TARGET)
 .PHONY: asm
 asm: $(ASM)
 
-## Find the total size
+## Find total section sizes
 .PHONY: size
 size: $(OBJ)
 	$(SIZE) -t $^
@@ -213,8 +213,12 @@ help:
 ## Find the per-function code size
 .PHONY: code
 code: CODEFLAGS+=-S
-code: $(OBJ) $(BUILDDIR)/lfs.code.csv
-	./scripts/code.py $(OBJ) $(CODEFLAGS)
+code: $(OBJ)
+	./scripts/code.py $^ $(CODEFLAGS)
+
+## Save the per-function code size
+.PHONY: code-csv
+code-csv: $(BUILDDIR)/lfs.code.csv
 
 ## Compare per-function code size
 .PHONY: code-diff
@@ -224,8 +228,12 @@ code-diff: $(OBJ)
 ## Find the per-function data size
 .PHONY: data
 data: DATAFLAGS+=-S
-data: $(OBJ) $(BUILDDIR)/lfs.data.csv
-	./scripts/data.py $(OBJ) $(DATAFLAGS)
+data: $(OBJ)
+	./scripts/data.py $^ $(DATAFLAGS)
+
+## Save the per-function data size
+.PHONY: data-csv
+data-csv: $(BUILDDIR)/lfs.data.csv
 
 ## Compare per-function data size
 .PHONY: data-diff
@@ -235,8 +243,12 @@ data-diff: $(OBJ)
 ## Find the per-function stack usage
 .PHONY: stack
 stack: STACKFLAGS+=-S
-stack: $(CI) $(BUILDDIR)/lfs.stack.csv
-	./scripts/stack.py $(CI) $(STACKFLAGS)
+stack: $(CI)
+	./scripts/stack.py $^ $(STACKFLAGS)
+
+## Save the per-function stack usage
+.PHONY: stack-csv
+stack-csv: $(BUILDDIR)/lfs.stack.csv
 
 ## Compare per-function stack usage
 .PHONY: stack-diff
@@ -246,8 +258,12 @@ stack-diff: $(CI)
 ## Find the per-function context
 .PHONY: ctx
 ctx: CTXFLAGS+=-S
-ctx: $(OBJ) $(BUILDDIR)/lfs.ctx.csv
-	./scripts/ctx.py $(OBJ) $(CTXFLAGS)
+ctx: $(OBJ)
+	./scripts/ctx.py $^ $(CTXFLAGS)
+
+## Save the per-function context
+.PHONY: ctx-csv
+ctx-csv: $(BUILDDIR)/lfs.ctx.csv
 
 ## Compare per-function context
 .PHONY: ctx-diff
@@ -258,50 +274,56 @@ ctx-diff: $(CI)
 .PHONY: funcs
 funcs: SUMMARYFLAGS+=-S
 funcs: SHELL=/bin/bash
-funcs: \
+funcs: $(OBJ) $(CI)
+	$(strip ./scripts/csv.py \
+		<(./scripts/code.py $(OBJ) $(CODEFLAGS) -o-) \
+		<(./scripts/stack.py $(CI) $(STACKFLAGS) -o-) \
+	    <(./scripts/ctx.py $(OBJ) $(CTXFLAGS) -o-) \
+		-bfunction \
+		-fcode=code_size \
+		-fstack='max(stack_limit)' \
+		-fctx='max(ctx_size)' \
+		$(SUMMARYFLAGS))
+
+## Save function sizes
+.PHONY: funcs-csv
+funcs-csv: SHELL=/bin/bash
+funcs-csv: \
 		$(BUILDDIR)/lfs.code.csv \
 		$(BUILDDIR)/lfs.stack.csv \
 		$(BUILDDIR)/lfs.ctx.csv
-	$(strip ./scripts/csv.py \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.code.csv \
-			-fcode=size -q -o-) \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.stack.csv \
-			-fstack='max(limit)' -q -o-) \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.ctx.csv \
-			-fctx='max(size)' -q -o-) \
-		-bfunction -fcode -fstack='max(stack)' -fctx='max(ctx)' \
-		$(SUMMARYFLAGS))
 
 ## Compare function sizes
 .PHONY: funcs-diff
 funcs-diff: SHELL=/bin/bash
 funcs-diff: $(OBJ) $(CI)
 	$(strip ./scripts/csv.py \
-		<(./scripts/csv.py \
-			<(./scripts/code.py $(OBJ) -q $(CODEFLAGS) -o-) \
-			-fcode=size -q -o-) \
-		<(./scripts/csv.py \
-			<(./scripts/stack.py $(CI) -q $(STACKFLAGS) -o-) \
-			-fstack='max(limit)' -q -o-) \
-		<(./scripts/csv.py \
-			<(./scripts/ctx.py $(OBJ) -q $(CTXFLAGS) -o-) \
-			-fctx='max(size)' -q -o-) \
-		-bfunction -fcode -fstack='max(stack)' -fctx='max(ctx)' \
-		$(SUMMARYFLAGS) -d <(./scripts/csv.py \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.code.csv \
-				-fcode=size -q -o-) \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.stack.csv \
-				-fstack='max(limit)' -q -o-) \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.ctx.csv \
-				-fctx='max(size)' -q -o-) \
-			-fcode -fstack='max(stack)' -fctx='max(ctx)' \
-			-q -o-))
+		<(./scripts/code.py $(OBJ) $(CODEFLAGS) -o-) \
+		<(./scripts/stack.py $(CI) $(STACKFLAGS) -o-) \
+		<(./scripts/ctx.py $(OBJ) $(CTXFLAGS) -o-) \
+		-bfunction \
+		-fcode=code_size \
+		-fstack='max(stack_limit)' \
+		-fctx='max(ctx_size)' \
+		-d <(./scripts/csv.py \
+			$(BUILDDIR)/lfs.code.csv \
+			$(BUILDDIR)/lfs.stack.csv \
+			$(BUILDDIR)/lfs.ctx.csv \
+			-fcode_size=code_size \
+			-fstack_limit='max(stack_limit)' \
+			-fctx_size='max(ctx_size)' \
+			-o-) \
+		$(SUMMARYFLAGS))
 
 ## Find struct sizes
 .PHONY: structs
 structs: STRUCTSFLAGS+=-S
-structs: $(OBJ) $(BUILDDIR)/lfs.structs.csv
-	./scripts/structs.py $(OBJ) $(STRUCTSFLAGS)
+structs: $(OBJ)
+	./scripts/structs.py $^ $(STRUCTSFLAGS)
+
+## Save struct sizes
+.PHONY: structs-csv
+structs-csv: $(BUILDDIR)/lfs.structs.csv
 
 ## Compare struct sizes
 .PHONY: structs-diff
@@ -311,11 +333,15 @@ structs-diff: $(OBJ)
 ## Find the line/branch coverage after a test run
 .PHONY: cov
 cov: COVFLAGS+=-s
-cov: $(GCDA) $(BUILDDIR)/lfs.cov.csv
-	$(strip ./scripts/cov.py $(GCDA) \
+cov: $(GCDA)
+	$(strip ./scripts/cov.py $^ \
 		$(patsubst %,-F%,$(SRC)) \
 		$(COVFLAGS))
 
+## Save line/branch coverage
+.PHONY: cov-csv
+cov-csv: $(BUILDDIR)/lfs.cov.csv
+
 ## Compare line/branch coverage
 .PHONY: cov-diff
 cov-diff: $(GCDA)
@@ -326,11 +352,15 @@ cov-diff: $(GCDA)
 ## Find the perf results after bench run with PERFGEN
 .PHONY: perf
 perf: PERFFLAGS+=-S
-perf: $(BENCH_PERF) $(BUILDDIR)/lfs.perf.csv
-	$(strip ./scripts/perf.py $(BENCH_PERF) \
+perf: $(BENCH_PERF)
+	$(strip ./scripts/perf.py $^ \
 		$(patsubst %,-F%,$(SRC)) \
 		$(PERFFLAGS))
 
+## Save perf results
+.PHONY: perf-csv
+perf-csv: $(BUILDDIR)/lfs.perf.csv
+
 ## Compare perf results
 .PHONY: perf-diff
 perf-diff: $(BENCH_PERF)
@@ -341,11 +371,15 @@ perf-diff: $(BENCH_PERF)
 ## Find the perfbd results after a bench run
 .PHONY: perfbd
 perfbd: PERFBDFLAGS+=-S
-perfbd: $(BENCH_TRACE) $(BUILDDIR)/lfs.perfbd.csv
-	$(strip ./scripts/perfbd.py $(BENCH_RUNNER) $(BENCH_TRACE) \
+perfbd: $(BENCH_TRACE)
+	$(strip ./scripts/perfbd.py $(BENCH_RUNNER) $^ \
 		$(patsubst %,-F%,$(SRC)) \
 		$(PERFBDFLAGS))
 
+## Save perfbd results
+.PHONY: perfbd-csv
+perfbd-csv: $(BUILDDIR)/lfs.perfbd.csv
+
 ## Compare perfbd results
 .PHONY: perfbd-diff
 perfbd-diff: $(BENCH_TRACE)
@@ -356,22 +390,27 @@ perfbd-diff: $(BENCH_TRACE)
 ## Find a summary of compile-time sizes
 .PHONY: summary sizes
 summary sizes: SHELL=/bin/bash
-summary sizes: \
+summary sizes: $(OBJ) $(CI)
+	$(strip ./scripts/csv.py \
+		<(./scripts/code.py $(OBJ) $(CODEFLAGS) -o-) \
+		<(./scripts/data.py $(OBJ) $(DATAFLAGS) -o-) \
+		<(./scripts/stack.py $(CI) $(STACKFLAGS) -o-) \
+		<(./scripts/ctx.py $(OBJ) $(CTXFLAGS) -o-) \
+		-bfunction \
+		-fcode=code_size \
+		-fdata=data_size \
+		-fstack='max(stack_limit)' \
+		-fctx='max(ctx_size)' \
+		-Y $(SUMMARYFLAGS))
+
+## Save compile-time sizes
+.PHONY: summary-csv sizes-csv
+summary-csv sizes-csv: SHELL=/bin/bash
+summary-csv sizes-csv: \
 		$(BUILDDIR)/lfs.code.csv \
 		$(BUILDDIR)/lfs.data.csv \
 		$(BUILDDIR)/lfs.stack.csv \
 		$(BUILDDIR)/lfs.ctx.csv
-	$(strip ./scripts/csv.py \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.code.csv \
-			-fcode=size -q -o-) \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.data.csv \
-			-fdata=size -q -o-) \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.stack.csv \
-			-fstack='max(limit)' -q -o-) \
-		<(./scripts/csv.py $(BUILDDIR)/lfs.ctx.csv \
-			-fctx='max(size)' -q -o-) \
-		-bfunction -fcode -fdata -fstack='max(stack)' -fctx='max(ctx)' \
-		-Y $(SUMMARYFLAGS))
 
 ## Compare compile-time sizes
 .PHONY: summary-diff sizes-diff
@@ -379,33 +418,59 @@ summary-diff sizes-diff: SHELL=/bin/bash
 summary-diff sizes-diff: $(OBJ) $(CI)
 	$(strip ./scripts/csv.py \
 		<(./scripts/csv.py \
-			<(./scripts/csv.py \
-				<(./scripts/code.py $(OBJ) -q $(CODEFLAGS) -o-) \
-				-fcode=size -q -o-) \
-			<(./scripts/csv.py \
-				<(./scripts/data.py $(OBJ) -q $(DATAFLAGS) -o-) \
-				-fdata=size -q -o-) \
-			<(./scripts/csv.py \
-				<(./scripts/stack.py $(CI) -q $(STACKFLAGS) -o-) \
-				-fstack='max(limit)' -q -o-) \
-			<(./scripts/csv.py \
-				<(./scripts/ctx.py $(OBJ) -q $(CTXFLAGS) -o-) \
-				-fctx='max(size)' -q -o-) \
-			-fcode -fdata -fstack='max(stack)' -fctx='max(ctx)' \
-			-bbuild=AFTER -q -o-) \
+			<(./scripts/code.py $(OBJ) $(CODEFLAGS) -o-) \
+			<(./scripts/data.py $(OBJ) $(DATAFLAGS) -o-) \
+			<(./scripts/stack.py $(CI) $(STACKFLAGS) -o-) \
+			<(./scripts/ctx.py $(OBJ) $(CTXFLAGS) -o-) \
+			-bbuild=AFTER \
+			-fcode=code_size \
+			-fdata=data_size \
+			-fstack='max(stack_limit)' \
+			-fctx='max(ctx_size)' \
+			-o-) \
 		<(./scripts/csv.py \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.code.csv \
-				-fcode=size -q -o-) \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.data.csv \
-				-fdata=size -q -o-) \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.stack.csv \
-				-fstack='max(limit)' -q -o-) \
-			<(./scripts/csv.py $(BUILDDIR)/lfs.ctx.csv \
-				-fctx='max(size)' -q -o-) \
-			-fcode -fdata -fstack='max(stack)' -fctx='max(ctx)' \
-			-bbuild=BEFORE -q -o-) \
+			$(BUILDDIR)/lfs.code.csv \
+			$(BUILDDIR)/lfs.data.csv \
+			$(BUILDDIR)/lfs.stack.csv \
+			$(BUILDDIR)/lfs.ctx.csv \
+			-bbuild=BEFORE \
+			-fcode=code_size \
+			-fdata=data_size \
+			-fstack='max(stack_limit)' \
+			-fctx='max(ctx_size)' \
+			-o-) \
 		-bbuild -cBEFORE -Q $(SUMMARYFLAGS))
 
+
+## Generate codemap ascii art
+.PHONY: codemap
+codemap: CODEMAPFLAGS+=-H6
+codemap: $(OBJ) $(CI)
+	./scripts/codemap.py $^ $(CODEMAPFLAGS)
+
+## Generate stackmap ascii art
+.PHONY: stackmap
+stackmap: CODEMAPFLAGS+=-H6
+stackmap: $(OBJ) $(CI)
+	./scripts/codemap.py $^ $(CODEMAPFLAGS) --tile-frames
+
+## Generate ctxmap ascii art
+.PHONY: ctxmap
+ctxmap: CODEMAPFLAGS+=-H6
+ctxmap: $(OBJ) $(CI)
+	./scripts/codemap.py $^ $(CODEMAPFLAGS) --tile-ctx
+
+## Generate a codemap svg
+.PHONY: codemap-svg
+codemap-svg: CODEMAPFLAGS+=-W1400 -H750 --dark
+codemap-svg: $(BUILDDIR)/lfs.codemap.svg
+
+## Generate a tiny codemap svg, where 1 pixel ~= 1 byte
+.PHONY: codemap-tiny-svg
+codemap-tiny-svg: CODEMAPFLAGS+=--dark
+codemap-tiny-svg: $(BUILDDIR)/lfs.codemap-tiny.svg
+
+
 ## Build the test-runner
 .PHONY: test-runner build-tests
 test-runner build-tests: CFLAGS+=$(TEST_CFLAGS)
@@ -435,16 +500,24 @@ test-list list-tests: test-runner
 ## Summarize the test results
 .PHONY: testmarks
 testmarks: SUMMARYFLAGS+=-spassed -Stime
-testmarks: $(TEST_CSV) $(BUILDDIR)/lfs.test.csv
-	$(strip ./scripts/csv.py $(TEST_CSV) \
-		-bsuite -fpassed -ftime \
+testmarks: $(TEST_CSV)
+	$(strip ./scripts/csv.py $^ \
+		-bsuite \
+		-fpassed=test_passed \
+		-ftime=test_time \
 		$(SUMMARYFLAGS))
 
+## Save the test results
+.PHONY: testmarks-csv
+testmarks-csv: $(BUILDDIR)/lfs.test.csv
+
 ## Compare test results against a previous run
 .PHONY: testmarks-diff
 testmarks-diff: $(TEST_CSV)
 	$(strip ./scripts/csv.py $^ \
-		-bsuite -fpassed -ftime \
+		-bsuite \
+		-fpassed=test_passed \
+		-ftime=test_time \
 		$(SUMMARYFLAGS) -d $(BUILDDIR)/lfs.test.csv)
 
 ## Build the bench-runner
@@ -476,16 +549,26 @@ bench-list list-benches: bench-runner
 ## Summarize the bench results
 .PHONY: benchmarks
 benchmarks: SUMMARYFLAGS+=-Serased -Sproged -Sreaded
-benchmarks: $(BENCH_CSV) $(BUILDDIR)/lfs.bench.csv
-	$(strip ./scripts/csv.py $(BENCH_CSV) \
-		-bsuite -freaded -fproged -ferased \
+benchmarks: $(BENCH_CSV)
+	$(strip ./scripts/csv.py $^ \
+		-bsuite \
+		-freaded=bench_readed \
+		-fproged=bench_proged \
+		-ferased=bench_erased \
 		$(SUMMARYFLAGS))
 
+## Save the bench results
+.PHONY: benchmarks-csv
+benchmarks-csv: $(BUILDDIR)/lfs.bench.csv
+
 ## Compare bench results against a previous run
 .PHONY: benchmarks-diff
 benchmarks-diff: $(BENCH_CSV)
 	$(strip ./scripts/csv.py $^ \
-		-bsuite -freaded -fproged -ferased \
+		-bsuite \
+		-freaded=bench_readed \
+		-fproged=bench_proged \
+		-ferased=bench_erased \
 		$(SUMMARYFLAGS) -d $(BUILDDIR)/lfs.bench.csv)
 
 
@@ -497,40 +580,46 @@ benchmarks-diff: $(BENCH_CSV)
 .SECONDARY:
 
 $(BUILDDIR)/lfs: $(OBJ)
-	$(CC) $(CFLAGS) $^ $(LFLAGS) -o $@
+	$(CC) $(CFLAGS) $^ $(LFLAGS) -o$@
 
 $(BUILDDIR)/liblfs.a: $(OBJ)
 	$(AR) rcs $@ $^
 
 $(BUILDDIR)/lfs.code.csv: $(OBJ)
-	./scripts/code.py $^ -q $(CODEFLAGS) -o $@
+	./scripts/code.py $^ $(CODEFLAGS) -o$@
 
 $(BUILDDIR)/lfs.data.csv: $(OBJ)
-	./scripts/data.py $^ -q $(DATAFLAGS) -o $@
+	./scripts/data.py $^ $(DATAFLAGS) -o$@
 
 $(BUILDDIR)/lfs.stack.csv: $(CI)
-	./scripts/stack.py $^ -q $(STACKFLAGS) -o $@
+	./scripts/stack.py $^ $(STACKFLAGS) -o$@
 
 $(BUILDDIR)/lfs.ctx.csv: $(OBJ)
-	./scripts/ctx.py $^ -q $(CTXFLAGS) -o $@
+	./scripts/ctx.py $^ $(CTXFLAGS) -o$@
 
 $(BUILDDIR)/lfs.structs.csv: $(OBJ)
-	./scripts/structs.py $^ -q $(STRUCTSFLAGS) -o $@
+	./scripts/structs.py $^ $(STRUCTSFLAGS) -o$@
 
 $(BUILDDIR)/lfs.cov.csv: $(GCDA)
 	$(strip ./scripts/cov.py $^ \
 		$(patsubst %,-F%,$(SRC)) \
-		-q $(COVFLAGS) -o $@)
+		$(COVFLAGS) -o$@)
 
 $(BUILDDIR)/lfs.perf.csv: $(BENCH_PERF)
 	$(strip ./scripts/perf.py $^ \
 		$(patsubst %,-F%,$(SRC)) \
-		-q $(PERFFLAGS) -o $@)
+		$(PERFFLAGS) -o$@)
 
 $(BUILDDIR)/lfs.perfbd.csv: $(BENCH_TRACE)
 	$(strip ./scripts/perfbd.py $(BENCH_RUNNER) $^ \
 		$(patsubst %,-F%,$(SRC)) \
-		-q $(PERFBDFLAGS) -o $@)
+		$(PERFBDFLAGS) -o$@)
+
+$(BUILDDIR)/lfs.codemap.svg: $(OBJ) $(CI)
+	./scripts/codemapd3.py $^ $(CODEMAPFLAGS) -o$@
+
+$(BUILDDIR)/lfs.codemap-tiny.svg: $(OBJ) $(CI)
+	./scripts/codemapd3.py $^ --tiny $(CODEMAPFLAGS) -o$@
 
 $(BUILDDIR)/lfs.test.csv: $(TEST_CSV)
 	cp $^ $@
@@ -539,10 +628,10 @@ $(BUILDDIR)/lfs.bench.csv: $(BENCH_CSV)
 	cp $^ $@
 
 $(BUILDDIR)/runners/test_runner: $(TEST_OBJ)
-	$(CC) $(CFLAGS) $^ $(LFLAGS) -o $@
+	$(CC) $(CFLAGS) $^ $(LFLAGS) -o$@
 
 $(BUILDDIR)/runners/bench_runner: $(BENCH_OBJ)
-	$(CC) $(CFLAGS) $^ $(LFLAGS) -o $@
+	$(CC) $(CFLAGS) $^ $(LFLAGS) -o$@
 
 # our main build rule generates .o, .d, and .ci files, the latter
 # used for stack analysis
@@ -550,25 +639,25 @@ $(BUILDDIR)/%.o $(BUILDDIR)/%.ci: %.c
 	$(CC) -c -MMD $(CFLAGS) $< -o $(BUILDDIR)/$*.o
 
 $(BUILDDIR)/%.s: %.c
-	$(CC) -S $(CFLAGS) $< -o $@
+	$(CC) -S $(CFLAGS) $< -o$@
 
 $(BUILDDIR)/%.a.c: %.c
-	$(PRETTYASSERTS) -Plfs_ $< -o $@
+	$(PRETTYASSERTS) -Plfs_ $< -o$@
 
 $(BUILDDIR)/%.a.c: $(BUILDDIR)/%.c
-	$(PRETTYASSERTS) -Plfs_ $< -o $@
+	$(PRETTYASSERTS) -Plfs_ $< -o$@
 
 $(BUILDDIR)/%.t.c: %.toml
-	./scripts/test.py -c $< $(TESTCFLAGS) -o $@
+	./scripts/test.py -c $< $(TESTCFLAGS) -o$@
 
 $(BUILDDIR)/%.t.c: %.c $(TESTS)
-	./scripts/test.py -c $(TESTS) -s $< $(TESTCFLAGS) -o $@
+	./scripts/test.py -c $(TESTS) -s $< $(TESTCFLAGS) -o$@
 
 $(BUILDDIR)/%.b.c: %.toml
-	./scripts/bench.py -c $< $(BENCHCFLAGS) -o $@
+	./scripts/bench.py -c $< $(BENCHCFLAGS) -o$@
 
 $(BUILDDIR)/%.b.c: %.c $(BENCHES)
-	./scripts/bench.py -c $(BENCHES) -s $< $(BENCHCFLAGS) -o $@
+	./scripts/bench.py -c $(BENCHES) -s $< $(BENCHCFLAGS) -o$@
 
 ## Clean everything
 .PHONY: clean
@@ -583,6 +672,8 @@ clean:
 	rm -f $(BUILDDIR)/lfs.cov.csv
 	rm -f $(BUILDDIR)/lfs.perf.csv
 	rm -f $(BUILDDIR)/lfs.perfbd.csv
+	rm -f $(BUILDDIR)/lfs.codemap.svg
+	rm -f $(BUILDDIR)/lfs.codemap-tiny.svg
 	rm -f $(BUILDDIR)/lfs.test.csv
 	rm -f $(BUILDDIR)/lfs.bench.csv
 	rm -f $(OBJ)