1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
#!/bin/bash
# sizes a memory map to the program it holds, before the program is compiled for it.
# src/tools/automap.sh PRESET OUTDIR FILE...
# PRESET is run, small, default or lsp. DOCS=1 makes the genome with its doc comments. FILE... are appended after the map's own
# rt.zc (and compiler.zc, for the presets that carry the compiler). the result
# is OUTDIR/memmap.h and OUTDIR/genome.bin, and they agree with each other. a core
# compiled with -IOUTDIR --embed-dir=OUTDIR embeds that image (src/core/genome.h).
#
# a genome's length doesn't depend on where it lives (every address is a one
# word literal), so two passes are enough: compile once on the preset's map
# to learn the length, then lay the map out again with a genome slot of exactly
# that length, rounded up to 4096 words, and let a fixed-size map grow if it has
# to. the second compile must come out the same length, and that is checked.
# zc0 reads the map at build time, so it is built again for each layout.
# GENMAP can name a genmap that is already built.
set -e
case "${1:-}" in
--help|-h) printf '%s\n' 'usage: src/tools/automap.sh run|small|default|lsp OUTDIR FILE...' 'builds a genome and memory map sized to the supplied source files.' 'output: OUTDIR/genome.bin and OUTDIR/memmap.h' 'environment: CC selects the c compiler; DOCS=1 retains documentation; GENMAP selects genmap.'; exit 0 ;;
-*) echo "automap: unknown option $1; use --help for usage" >&2; exit 2 ;;
esac
cd "$(dirname "$0")/../.."
[[ $# -ge 2 ]] || { echo 'usage: src/tools/automap.sh run|small|default|lsp OUTDIR FILE...' >&2; exit 2; }
P=$1; O=$2; shift 2
[ -n "$P" ] && [ -n "$O" ] || { echo "usage: src/tools/automap.sh run|small|default|lsp OUTDIR FILE..." >&2; exit 2; }
CC=${CC:-$(sh src/tools/findcc.sh)}
mkdir -p "$O"
ZC0=$O/.zc0
if [ -z "$GENMAP" ]; then
GENMAP=$O/.genmap
if [ ! -x "$GENMAP" ] || [ src/tools/genmap.c -nt "$GENMAP" ]; then $CC -O2 -w -fwrapv src/tools/genmap.c -o "$GENMAP"; fi
fi
lay() { # $1 = genome slot, or empty for the preset's own
rm -rf "$O/map"
"$GENMAP" --preset "$P" --grow ${1:+--genome $1} -o "$O/map" >/dev/null 2>&1
$CC -O1 -w -fwrapv src/tools/zc0.c -I"$O/map" -Isrc/core -o "$ZC0"
$CC -O1 -w -fwrapv src/tools/mkgenome.c -I"$O/map" -o "$O/.mkgenome"
}
build() {
if [ -f "$O/map/compiler.zc" ]; then cat "$O/map/rt.zc" src/core/core.zc "$O/map/compiler.zc" "$@"; else cat "$O/map/rt.zc" src/core/core.zc "$@"; fi | "$ZC0" > "$O/image.bin"
"$O/.mkgenome" < "$O/image.bin" > "$O/genome.bin"
}
# with DOCS=1 the genome is made again with zc0 built for docs (ZC0DOCS), so the
# image carries the doc comments of the sources and the program can answer
# docofs(). the image is the same code either way; the docs are stored after it.
docs() {
$CC -O1 -w -fwrapv -DZC0DOCS src/tools/zc0.c -I"$O/map" -Isrc/core -o "$O/.zc0docs"
if [ -f "$O/map/compiler.zc" ]; then cat "$O/map/rt.zc" src/core/core.zc "$O/map/compiler.zc" "$@"; else cat "$O/map/rt.zc" src/core/core.zc "$@"; fi | "$O/.zc0docs" > "$O/image.bin"
"$O/.mkgenome" < "$O/image.bin" > "$O/genome.bin"
}
len() { echo $(( $(wc -c < "$1") / 8 )); }
lay ""
build "$@"
glen=$(len "$O/genome.bin")
slot=$(( (glen + 4095) / 4096 * 4096 ))
lay "$slot"
build "$@"
if [ -n "$DOCS" ]; then
lay $((slot + 65536)) # room for the image with its docs while it is being made
docs "$@"
glen=$(len "$O/genome.bin")
slot=$(( (glen + 4095) / 4096 * 4096 ))
lay "$slot"
docs "$@"
fi
rm -f "$O/image.bin"
[ "$(len "$O/genome.bin")" = "$glen" ] || { echo "automap: the genome changed length with the map" >&2; exit 1; }
cp "$O/map/memmap.h" "$O/map/map.txt" "$O/"
echo "automap $P: genome $glen words in a slot of $slot, $(grep -m1 '^MW' "$O/map/map.txt")"
|
