From a5c14f089ba4b0dcd26ca1f099d40129c2bfcc0a Mon Sep 17 00:00:00 2001 From: Paul Mathieu Date: Sun, 30 Mar 2025 17:42:20 -0700 Subject: [PATCH] mbv: use new ninja-based build --- mbv/Dockerfile | 11 +- mbv/Makefile | 81 ------- mbv/README.md | 0 mbv/{ => apps}/app.ld | 0 mbv/{ => apps/helloworld}/helloworld.cc | 0 mbv/{ => bootloader}/bootloader.cc | 0 mbv/{ => bootloader}/bootloader.ld | 0 mbv/configure | 300 ++++++++++++++++++++++++ mbv/{ => hal}/start.cc | 0 9 files changed, 307 insertions(+), 85 deletions(-) create mode 100644 mbv/README.md rename mbv/{ => apps}/app.ld (100%) rename mbv/{ => apps/helloworld}/helloworld.cc (100%) rename mbv/{ => bootloader}/bootloader.cc (100%) rename mbv/{ => bootloader}/bootloader.ld (100%) create mode 100755 mbv/configure rename mbv/{ => hal}/start.cc (100%) diff --git a/mbv/Dockerfile b/mbv/Dockerfile index 64b5dde..16d1be7 100644 --- a/mbv/Dockerfile +++ b/mbv/Dockerfile @@ -2,10 +2,13 @@ ARG TARGET FROM debian:bookworm AS deps +# possible values: x64, arm64 +ARG ARCH=x64 + RUN DEBIAN_FRONTEND=noninteractive apt-get update && \ - apt-get install -y make clang libgmock-dev gdb curl && \ + apt-get install -y make clang libgmock-dev gdb curl ninja-build && \ apt-get clean && rm -rf /var/lib/apt/lists -RUN cd /opt && curl -L https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack/releases/download/v14.2.0-3/xpack-riscv-none-elf-gcc-14.2.0-3-linux-x64.tar.gz | tar -xz +RUN cd /opt && curl -L https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack/releases/download/v14.2.0-3/xpack-riscv-none-elf-gcc-14.2.0-3-linux-${ARCH}.tar.gz | tar -xz FROM deps AS dev @@ -17,10 +20,10 @@ ARG TARGET=${TARGET} ADD . /workspace WORKDIR /workspace -RUN make ${TARGET} +RUN ./configure --version=${VERSION} && ninja -C build ../out/${TARGET} FROM scratch AS export ARG TARGET=${TARGET} -COPY --from=build /workspace/${TARGET} / +COPY --from=build /workspace/out/${TARGET} / diff --git a/mbv/Makefile b/mbv/Makefile index 3ce0d32..d8327da 100644 --- a/mbv/Makefile +++ b/mbv/Makefile @@ -1,84 +1,3 @@ -TOOLCHAIN_PATH = /opt/xpack-riscv-none-elf-gcc-14.2.0-3/bin/ -CC = $(TOOLCHAIN_PATH)riscv-none-elf-gcc -LD = $(TOOLCHAIN_PATH)riscv-none-elf-g++ -CXX = $(TOOLCHAIN_PATH)riscv-none-elf-g++ -OBJCOPY = $(TOOLCHAIN_PATH)riscv-none-elf-objcopy - -linker_script = bootloader.ld -includes = -sources = - -CFLAGS = -march=rv32i -g -ffunction-sections -fdata-sections -Os -Werror -Wall -flto -CXXFLAGS = $(CFLAGS) -std=c++20 -fno-exceptions -fcoroutines -CPPFLAGS = -MD -MP -LDFLAGS = -march=rv32i \ - -g \ - -Wl,--gc-sections -Os \ - -Wl,--print-memory-usage -flto - -sources += hal/lib/common/xil_assert.c -includes += -Ihal/lib/common - -sources += hal/uart/xuartlite.c hal/uart/xuartlite_stats.c hal/uart/xuartlite_intr.c -includes += -Ihal/uart - -bootloader_objects = bootloader.o start.o $(sources:.c=.o) -helloworld_objects = helloworld.o start.o $(sources:.c=.o) - -all_objects = $(bootloader_objects) $(helloworld_objects) -deps = $(all_objects:.o=.d) - -CPPFLAGS += $(includes) - -%.bin: %.elf - $(OBJCOPY) -O binary $< $@ - -%.elf: app.ld - $(LD) -Wl,-Tapp.ld $(LDFLAGS) -o $@ $(objects) - -bootloader.elf: $(bootloader_objects) bootloader.ld - $(LD) -Wl,-Tbootloader.ld $(LDFLAGS) -o $@ $(bootloader_objects) - -helloworld.elf: objects = $(helloworld_objects) -helloworld.elf: $(helloworld_objects) - -HOSTCXX = clang++ -HOSTLDFLAGS = -lgmock -lgtest -lgtest_main -L/usr/local/opt/llvm/lib -L/usr/local/lib -HOSTCFLAGS = -std=c++20 -g\ - -I/usr/local/opt/llvm/include \ - -I/usr/local/include \ - -I/usr/local/include \ - -MP -MD - -TSAN_CFLAGS = $(HOSTCFLAGS) -fsanitize=thread -ASAN_CFLAGS = $(HOSTCFLAGS) -fsanitize=address -fsanitize=leak - -tests = - -.PHONY: test -test: $(tests) ## Run tests - -%.run: test/% - TSAN_OPTIONS='suppressions=tsan.suppressions' ASAN_OPTIONS=detect_leaks=1 ./$< - -%.host.o: %.cc - $(HOSTCXX) $(HOSTCFLAGS) -c -o $@ $< - -test/%_test: | mktest - $(HOSTCXX) $(HOSTCFLAGS) -o $@ $^ $(HOSTLDFLAGS) - -test/%_asan: | mktest - $(HOSTCXX) $(ASAN_CFLAGS) -o $@ $^ $(HOSTLDFLAGS) - -test/%_tsan: | mktest - $(HOSTCXX) $(TSAN_CFLAGS) -o $@ $^ $(HOSTLDFLAGS) - -.PHONY: mktest -mktest: - mkdir -p test - -test_deps = - .PHONY: bootloader bootloader: ## Build the bootloader in docker docker build -o . --target export --build-arg TARGET=bootloader.elf . diff --git a/mbv/README.md b/mbv/README.md new file mode 100644 index 0000000..e69de29 diff --git a/mbv/app.ld b/mbv/apps/app.ld similarity index 100% rename from mbv/app.ld rename to mbv/apps/app.ld diff --git a/mbv/helloworld.cc b/mbv/apps/helloworld/helloworld.cc similarity index 100% rename from mbv/helloworld.cc rename to mbv/apps/helloworld/helloworld.cc diff --git a/mbv/bootloader.cc b/mbv/bootloader/bootloader.cc similarity index 100% rename from mbv/bootloader.cc rename to mbv/bootloader/bootloader.cc diff --git a/mbv/bootloader.ld b/mbv/bootloader/bootloader.ld similarity index 100% rename from mbv/bootloader.ld rename to mbv/bootloader/bootloader.ld diff --git a/mbv/configure b/mbv/configure new file mode 100755 index 0000000..2016731 --- /dev/null +++ b/mbv/configure @@ -0,0 +1,300 @@ +#!/usr/bin/env python3 + +import argparse +import collections +import glob +import itertools +import os +import re + + +# global config +toolchain_path = f"/opt/xpack-riscv-none-elf-gcc-14.2.0-3" +toolchain_prefix = "riscv-none-elf-" +builddir = "build" +outdir = "out" +linker_script = "apps/app.ld" +hostcflags = "-g -std=c++20 -fprofile-instr-generate -fcoverage-mapping" +hostlibs = "-lgtest -lgmock -lgtest_main" +hostldflags = "-fprofile-instr-generate -fcoverage-mapping" +include_dirs = [ + "hal/uart", + "hal/lib/common", +] + +include_flags = [f"-I{os.path.relpath(i, builddir)}" for i in include_dirs] +project_flags = [ +] +cpp_flags = ["-DNDEBUG"] + include_flags + project_flags +common_flags = [ + "-g", + "-Wall", + "-Wextra", + "-flto", + "-march=rv32i", + "-ffunction-sections", + "-Oz", +] + +cc_flags = common_flags +cxx_flags = common_flags + ["-std=c++20", "-fno-rtti", "-fno-exceptions", "-Wno-missing-field-initializers"] +ldflags = [ + "-Oz", + "-g", + "-Wl,--gc-sections", + "-Wl,--print-memory-usage", + "-flto", + "-march=rv32i", +] + + +def get_cxx_flags(): + return cpp_flags + cxx_flags + + +def get_cc_flags(): + return cpp_flags + cc_flags + + +def get_ldflags(): + return ldflags + + +def add_cpp_flag(flag): + cpp_flags.append(flag) + + +def gen_rules(): + tools = {"cxx": "g++", "cc": "gcc", "as": "as", "objcopy": "objcopy"} + + tc_path = toolchain_path + tc_prefix = toolchain_prefix + + rules = f""" +rule cxx + command = $cxx -MMD -MT $out -MF $out.d {' '.join(get_cxx_flags())} -c $in -o $out + description = CXX $out + depfile = $out.d + deps = gcc + +rule cc + command = $cc -MMD -MT $out -MF $out.d {' '.join(get_cc_flags())} -c $in -o $out + description = CC $out + depfile = $out.d + deps = gcc + +rule as + command = $as $in -o $out + description = AS $out + +rule link + command = $cxx {' '.join(ldflags)} -Wl,-T$linker_script -o $out $in $libs + description = LINK $out + +rule objcopy + command = $objcopy -O binary $in $out + description = OBJCOPY $out + +rule hostcxx + command = clang++ -MMD -MT $out -MF $out.d {hostcflags} -c $in -o $out + description = HOSTCXX $out + depfile = $out.d + deps = gcc + +rule hostlink + command = clang++ {hostldflags} -o $out $in {hostlibs} + description = HOSTLINK $out + +rule profdata + command = llvm-profdata merge -sparse $profraw -o $out + description = PROFDATA + +rule cov + command = llvm-cov show --output-dir cov -format html --instr-profile $profdata $objects && touch $out + description = COV + +rule hosttest + command = LLVM_PROFILE_FILE=$in.profraw ./$in && touch $out +""" + + for var, tool in tools.items(): + toolpath = os.path.join(tc_path, "bin", f"{tc_prefix}{tool}") + yield f"{var} = {toolpath}" + + for line in rules.splitlines(): + yield line + + +def get_suffix_rule(filename, cxx_rule="cxx", cc_rule="cc"): + suffix = filename.split(".")[-1] + return collections.defaultdict( + lambda: None, + { + "c": cc_rule, + "cc": cxx_rule, + "cpp": cxx_rule, + "s": "as", + }, + )[suffix] + + +def make_cxx_rule(name, cflags=()): + cflags = " ".join(cflags + get_cxx_flags()) + rule = f""" +rule {name} + command = $cxx -MMD -MT $out -MF $out.d {cflags} -c $in -o $out + description = CXX $out + depfile = $out.d + deps = gcc +""" + return rule.splitlines() + + +def make_cc_rule(name, cflags=()): + cflags = " ".join(cflags + get_cc_flags()) + rule = f""" +rule {name} + command = $cc -MMD -MT $out -MF $out.d {cflags} -c $in -o $out + description = CC $out + depfile = $out.d + deps = gcc +""" + return rule.splitlines() + + +def source_set(name, sources, cflags=()): + builds = [ + (os.path.relpath(s, builddir), re.sub(r"\.\w+", ".o", s)) + for s in sources + if get_suffix_rule(s) is not None + ] + + lines = [] + + cxx_rule = "cxx" + cc_rule = "cc" + if cflags: + cxx_rule = f"cxx_{name}" + lines += make_cxx_rule(cxx_rule, cflags=cflags) + cc_rule = f"cc_{name}" + lines += make_cc_rule(cc_rule, cflags=cflags) + + for i, o in builds: + rule = get_suffix_rule(i, cxx_rule=cxx_rule, cc_rule=cc_rule) + if rule is None: + continue + lines.append(f"build {o}: {rule} {i}") + + return [b[1] for b in builds], lines + + +def build_source_set(source_set): + for line in source_set[1]: + yield line + + +def build_image(source_set, elf_out, dependencies=(), bin_out=None, linker_script=linker_script): + # to make it builddir-relative + linker_script = os.path.relpath(linker_script, builddir) + + elf_out = os.path.relpath(elf_out, builddir) + + objects, lines = source_set + for line in lines: + yield line + for objs, _ in dependencies: + objects += objs + objects = " ".join(objects) + + yield f"build {elf_out}: link {objects} | {linker_script}" + yield f" linker_script = {linker_script}" + if bin_out is not None: + bin_out = os.path.relpath(bin_out, builddir) + yield f"build {bin_out}: objcopy {elf_out}" + + +def build_test(name, sources): + builds = [ + (os.path.relpath(s, builddir), f"{name}_" + re.sub(r"\.\w+", ".o", s)) + for s in sources + ] + + out = name + + for i, o in builds: + rule = "hostcxx" + yield f"build {o}: {rule} {i}" + + objects = " ".join(b[1] for b in builds) + + yield f"build {out}: hostlink {objects}" + yield f"build {out}.run: hosttest {out}" + + +def make_coverage(binaries): + bins = " ".join(binaries) + profraw = " ".join(f"{x}.profraw" for x in binaries) + objects = " ".join(f"--object {x}" for x in binaries) + testruns = " ".join(f"{x}.run" for x in binaries) + yield f"build profdata: profdata | {testruns}" + yield f" profraw = {profraw}" + yield f"build cov/index.html: cov {bins} | profdata" + yield f" profdata = profdata" + yield f" objects = {objects}" + + +hal = source_set("hal", [ + "hal/start.cc", + "hal/lib/common/xil_assert.c", + "hal/uart/xuartlite.c", + "hal/uart/xuartlite_stats.c", + "hal/uart/xuartlite_intr.c", + ]) + +bootloader = source_set("bootloader", glob.glob("./bootloader/**/*.cc", recursive=True)) +helloworld = source_set("helloworld", glob.glob("./apps/helloworld/**/*.cc", recursive=True)) + +bootloader_image = build_image( + bootloader, + dependencies=[hal], + elf_out="out/bootloader.elf", + linker_script="bootloader/bootloader.ld", +) + +helloworld_image = build_image( + helloworld, + dependencies=[hal], + elf_out="out/helloworld.elf", + bin_out="out/helloworld.bin", +) + +all = [build_source_set(hal), bootloader_image, helloworld_image] + + +def parse_args(): + parser = argparse.ArgumentParser(description='Generate ninja build files.') + parser.add_argument('--version', required=True, + help='version tag (typically from `git describe`)') + return parser.parse_args() + + +def main(): + args = parse_args() + add_cpp_flag(f'-DGIT_VERSION_TAG=\\"{args.version}\\"') + header = gen_rules() + lines = itertools.chain(header, *all) + + if not os.path.exists(builddir): + os.mkdir(builddir) + + with open(os.path.join(builddir, "build.ninja"), "w") as f: + f.write("\n".join(lines)) + f.write("\n") + + print( + f'Configure done. Build with "ninja -C {builddir}". Output will be in {outdir}/' + ) + + +if __name__ == "__main__": + main() diff --git a/mbv/start.cc b/mbv/hal/start.cc similarity index 100% rename from mbv/start.cc rename to mbv/hal/start.cc