Github/littlefs
1
Fork 0
Code Actions Activity

make: Adopted script changes in the Makefile

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