Update lk build target to support arm32 builds

Author: arichardson

pycheribuild/config/compilation_targets.py

@@ -1033,6 +1033,8 @@ def base_sysroot_targets(cls, target: "CrossCompileTarget", config: "CheriConfig
 
     @classmethod
     def triple_for_target(cls, target: "CrossCompileTarget", config: "CheriConfig", *, include_version: bool) -> str:
+        if target.cpu_architecture == CPUArchitecture.ARM32:
+            return "armv7-unknown-none-eabi"  # TODO: Use an ArmV8 triple once QEMU supports it
         return target.cpu_architecture.value + "-unknown-elf"
 
     @property
@@ -1336,6 +1338,8 @@ class CompilationTargets(BasicCompilationTargets):
         BAREMETAL_NEWLIB_RISCV64_HYBRID,
         BAREMETAL_NEWLIB_RISCV64_PURECAP,
     )
+    FREESTANDING_ARM32 = CrossCompileTarget("arm32", CPUArchitecture.ARM32, BaremetalFreestandingTargetInfo)
+    FREESTANDING_AARCH64 = CrossCompileTarget("aarch64", CPUArchitecture.AARCH64, BaremetalFreestandingTargetInfo)
     FREESTANDING_MIPS64 = CrossCompileTarget("mips64", CPUArchitecture.MIPS64, BaremetalFreestandingTargetInfo)
     FREESTANDING_MORELLO_NO_CHERI = CrossCompileTarget(
         "morello-aarch64",
@@ -1389,6 +1393,8 @@ class CompilationTargets(BasicCompilationTargets):
         hybrid_target=FREESTANDING_RISCV64_HYBRID,
     )
     ALL_FREESTANDING_TARGETS = (
+        FREESTANDING_AARCH64,
+        FREESTANDING_ARM32,
         FREESTANDING_MIPS64,
         FREESTANDING_MORELLO_NO_CHERI,
         FREESTANDING_MORELLO_HYBRID,

pycheribuild/config/target_info.py

@@ -971,6 +971,9 @@ def is_riscv64(self, include_purecap: Optional[bool] = None) -> bool:
     def is_riscv(self, include_purecap: Optional[bool] = None) -> bool:
         return self.is_riscv32(include_purecap) or self.is_riscv64(include_purecap)
 
+    def is_arm32(self, include_purecap: Optional[bool] = None) -> bool:
+        return self._check_arch(CPUArchitecture.ARM32, include_purecap)
+
     def is_aarch64(self, include_purecap: Optional[bool] = None) -> bool:
         return self._check_arch(CPUArchitecture.AARCH64, include_purecap)
 

pycheribuild/projects/cross/littlekernel.py

@@ -27,6 +27,7 @@
 
 from .compiler_rt import BuildCompilerRtBuiltins
 from .crosscompileproject import CompilationTargets, CrossCompileMakefileProject, GitRepository
+from ..build_qemu import BuildQEMU
 from ..project import DefaultInstallDir
 from ..run_qemu import LaunchQEMUBase
 from ..simple_project import BoolConfigOption
@@ -39,8 +40,11 @@ class BuildLittleKernel(CrossCompileMakefileProject):
     target = "littlekernel"
     default_directory_basename = "lk"
     supported_architectures = (
+        CompilationTargets.FREESTANDING_ARM32,
+        CompilationTargets.FREESTANDING_AARCH64,
         CompilationTargets.FREESTANDING_MORELLO_NO_CHERI,
         CompilationTargets.FREESTANDING_MORELLO_PURECAP,
+        CompilationTargets.FREESTANDING_RISCV32,
         CompilationTargets.FREESTANDING_RISCV64,
         CompilationTargets.FREESTANDING_RISCV64_PURECAP,
     )
@@ -97,22 +101,28 @@ def setup(self):
         self.make_args.set(BUILDROOT=self.build_dir)
         if self.config.verbose:
             self.make_args.set(NOECHO="")
-        for var in ["CFLAGS", "CPPFLAGS", "CXXFLAGS", "LDFLAGS"]:
+        for var in ["CFLAGS", "CPPFLAGS", "CXXFLAGS", "LDFLAGS", "AR"]:
             del self.make_args.env_vars[var]
-        toolchain_prefix = str(self.sdk_bindir) + "/"
-        if self.compiling_for_riscv(include_purecap=True):
-            # Use hardfloat to avoid libgcc deps
-            self.make_args.set(RISCV_FPU=True)
         if self.compiling_for_cheri():
             self.make_args.set(ARCH_COMPILEFLAGS="")  # dont' override the default -mabi=
 
+        if self.compiling_for_arm32():
+            # Work around "error: unknown argument: '-mthumb-interwork'"
+            self.make_args.set(ENABLE_THUMB=0)
+
         self.set_make_cmd_with_args("LD", self.target_info.linker, ["--unresolved-symbols=report-all"])
-        if self.crosscompile_target.is_riscv(include_purecap=True) and self.use_mmu:
+        if self.crosscompile_target.is_riscv64(include_purecap=True) and self.use_mmu:
             self.make_args.set(RISCV_MMU="sv39", RISCV_MODE="supervisor")
+            # Use hardfloat to avoid libgcc deps
+            self.make_args.set(RISCV_FPU=1)
+        elif self.crosscompile_target.is_riscv32(include_purecap=True):
+            if self.use_mmu:
+                self.make_args.set(RISCV_MMU="sv32", RISCV_MODE="supervisor")
+            # Use softfloat to match compiler-rt ABI
+            self.make_args.set(RISCV_FPU=0)
         self.make_args.set(
-            TOOLCHAIN_PREFIX=toolchain_prefix,
-            ARCH_arm64_TOOLCHAIN_PREFIX=toolchain_prefix,
-            ARCH_riscv64_TOOLCHAIN_PREFIX=toolchain_prefix,
+            TOOLCHAIN_PREFIX=str(self.sdk_bindir) + "/llvm-",
+            CPPFILT=self.sdk_bindir / "llvm-cxxfilt",  # does not match the normal llvm-<binutil> pattern
         )
 
     def setup_late(self) -> None:
@@ -123,15 +133,20 @@ def setup_late(self) -> None:
     def kernel_path(self) -> Path:
         if self.compiling_for_aarch64(include_purecap=True):
             return self.build_dir / "build-qemu-virt-arm64-test/lk.elf"
-        elif self.compiling_for_riscv(include_purecap=True):
+        elif self.crosscompile_target.is_riscv32(include_purecap=True):
+            return self.build_dir / "build-qemu-virt-riscv32-test/lk.elf"
+        elif self.crosscompile_target.is_riscv64(include_purecap=True):
             return self.build_dir / "build-qemu-virt-riscv64-test/lk.elf"
+        elif self.compiling_for_arm32():
+            return self.build_dir / "build-qemu-virt-arm32-test/lk.elf"
         else:
             raise ValueError("Unsupported arch")
 
     def run_tests(self):
+        qemu = BuildQEMU.qemu_binary(self, xtarget=self.crosscompile_target)
         if self.compiling_for_aarch64(include_purecap=True):
             cmd = [
-                self.config.qemu_bindir / "qemu-system-aarch64",
+                qemu,
                 "-cpu",
                 "cortex-a53",
                 "-m",
@@ -151,9 +166,9 @@ def run_tests(self):
             if self.use_mmu:
                 bios_args = riscv_bios_arguments(self.crosscompile_target, self)
             cmd = [
-                self.config.qemu_bindir / "qemu-system-riscv64cheri",
+                qemu,
                 "-cpu",
-                "rv64",
+                "rv64" if self.crosscompile_target.is_riscv64(include_purecap=True) else "rv32",
                 "-m",
                 "512",
                 "-smp",
@@ -167,6 +182,23 @@ def run_tests(self):
                 self.kernel_path,
                 *bios_args,
             ]
+        elif self.compiling_for_arm32():
+            cmd = [
+                qemu,
+                "-cpu",
+                "cortex-a15",
+                "-m",
+                "512",
+                "-smp",
+                "1",
+                "-machine",
+                "virt,highmem=off",
+                "-net",
+                "none",
+                "-nographic",
+                "-kernel",
+                self.kernel_path,
+            ]
         else:
             return self.fatal("Unsupported arch")
         self.run_cmd(cmd, cwd=self.build_dir, give_tty_control=True)
@@ -175,7 +207,10 @@ def compile(self, **kwargs):
         if self.compiling_for_aarch64(include_purecap=True):
             self.run_make("qemu-virt-arm64-test", cwd=self.source_dir, parallel=True)
         elif self.compiling_for_riscv(include_purecap=True):
-            self.run_make("qemu-virt-riscv64-test", cwd=self.source_dir, parallel=True)
+            xlen = 64 if self.crosscompile_target.is_riscv64(include_purecap=True) else 32
+            self.run_make(f"qemu-virt-riscv{xlen}-test", cwd=self.source_dir, parallel=True)
+        elif self.compiling_for_arm32():
+            self.run_make("qemu-virt-arm32-test", cwd=self.source_dir, parallel=True)
         else:
             return self.fatal("Unsupported arch")
 

pycheribuild/projects/run_qemu.py

@@ -261,7 +261,11 @@ def get_chosen_qemu(cls, config: CheriConfig):
             supported_qemu_classes += [BuildQEMU]
             if not xtarget.is_hybrid_or_purecap_cheri():
                 supported_qemu_classes += [BuildUpstreamQEMU, None]
-        elif xtarget.is_any_x86() or xtarget.is_aarch64(include_purecap=False):
+        elif xtarget.is_arm32(include_purecap=False):
+            can_provide_src_via_smb = True
+            # Prefer CHERI QEMU for AArch64 like other architectures.
+            supported_qemu_classes += [BuildQEMU, BuildUpstreamQEMU, None]
+        elif xtarget.is_any_x86():
             # Default to CHERI QEMU instead of the system QEMU (for now)
             # Note: x86_64 can be either CHERI QEMU or system QEMU:
             supported_qemu_classes += [BuildQEMU, BuildUpstreamQEMU, None]

pycheribuild/projects/simple_project.py

@@ -789,6 +789,9 @@ def compiling_for_riscv(self, include_purecap: bool) -> bool:
     def compiling_for_aarch64(self, include_purecap: bool) -> bool:
         return self.crosscompile_target.is_aarch64(include_purecap=include_purecap)
 
+    def compiling_for_arm32(self) -> bool:
+        return self.crosscompile_target.is_arm32()
+
     def build_configuration_suffix(self, target: Optional[CrossCompileTarget] = None) -> str:
         """
         :param target: the target to use

pycheribuild/qemu_utils.py

@@ -86,6 +86,10 @@ def __init__(self, xtarget: CrossCompileTarget, want_debugger=False) -> None:
             self.qemu_arch_sufffix = "aarch64"
             self.can_boot_kernel_directly = False  # boot from disk
             self.machine_flags = ["-M", "virt,gic-version=3", "-cpu", "cortex-a72", "-bios", "edk2-aarch64-code.fd"]
+        elif xtarget.is_arm32(include_purecap=False):
+            self.qemu_arch_sufffix = "arm"
+            self.can_boot_kernel_directly = False  # boot from disk
+            self.machine_flags = ["-M", "virt", "-cpu", "cortex-15"]
         else:
             raise ValueError("Unknown target " + str(xtarget))