diff --git a/.github/configs/x86_64-ci.config b/.github/configs/x86_64-ci.config
deleted file mode 100644
index a270d8a1..00000000
--- a/.github/configs/x86_64-ci.config
+++ /dev/null
@@ -1,8 +0,0 @@
-CONFIG_ARCH_X86_64=y
-CONFIG_VERBOSE_INIT_LEVELS=y
-CONFIG_DEBUG_MM=y
-CONFIG_PARAVIRT=y
-CONFIG_KVM_GUEST=y
-CONFIG_BHYVE_GUEST=y
-CONFIG_EMULATOR_GUEST=y
-CONFIG_FLANTERM_CONSOLE=y
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 3b43a558..3418745c 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -31,6 +31,20 @@ jobs:
           mypy *.py
           mypy scripts/
 
+  lint-kernel:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+
+      - name: Build the platform toolchain
+        run: "${{ github.workspace }}/build.py --toolchain clang --toolchain-only"
+
+      - name: Check the coding conventions
+        run: "${{ github.workspace }}/build.py --toolchain clang --lint"
+
   build:
     runs-on: ${{ matrix.os }}
 
@@ -40,6 +54,7 @@ jobs:
         os: [ubuntu-latest, macos-latest]
         arch: [x86_64]
         toolchain: [gcc, clang]
+        preset: [debug-lite, release]
         exclude:
           # FIXME: the GCC build somehow ends up being corrupted with
           #        libexec/cc1 containing garbage data.
@@ -78,11 +93,20 @@ jobs:
           key: ${{ steps.toolchain-cache.outputs.cache-primary-key }}
 
       - name: Build the kernel
-        run: "${{ github.workspace }}/build.py --config ${{ github.workspace }}/.github/configs/${{ matrix.arch }}-ci.config --toolchain ${{ matrix.toolchain }} --no-tune-native"
+        run: "${{ github.workspace }}/build.py --arch ${{ matrix.arch }} --config ${{ matrix.preset }} --toolchain ${{ matrix.toolchain }} --no-tune-native"
+
+  unit-tests:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
 
       - name: Run the userspace unit tests
         run: "${{ github.workspace }}/build.py --unit-tests"
-
-      - if: ${{ matrix.toolchain == 'clang' && matrix.os == 'ubuntu-latest' }}
-        name: Check the coding conventions
-        run: "${{ github.workspace }}/build.py --config ${{ github.workspace }}/.github/configs/${{ matrix.arch }}-ci.config --toolchain ${{ matrix.toolchain }} --no-build --lint"
diff --git a/build.py b/build.py
index 73cc1c4e..4e7891ed 100755
--- a/build.py
+++ b/build.py
@@ -20,6 +20,7 @@
     sys.modules["kconfiglib"] = kc
 
     import scripts.build_utils.wsl_wrap as ww
+    import scripts.config_layers as cl
     import scripts.build_utils.package_manager as pm
     import scripts.build_utils.toolchain_builder as tb
     import scripts.build_utils.toolchain_args as ta
@@ -73,16 +74,6 @@
 # How long --run-for waits for the first output before giving up
 QEMU_SILENT_BOOT_SECONDS = 30
 
-ARCH_TO_CONFIG_KEY = {
-    "x86_64": "ARCH_X86_64",
-    "aarch64": "ARCH_AARCH64",
-}
-
-TOOLCHAIN_TO_CONFIG_KEY = {
-    "clang": "TOOLCHAIN_CLANG",
-    "gcc": "TOOLCHAIN_GCC",
-}
-
 
 @contextmanager
 def enter_work_dir(path: str) -> Iterator[None]:
@@ -180,28 +171,36 @@ def cmake_native_build_args(build_dir: str) -> List[str]:
     return ["--", "-Oline"]
 
 
-def cmake_build(
+def cmake_configure(
     args: argparse.Namespace, build_dir: str, extra_args: List[str] = [],
-    reconfigure_cb: Optional[Callable[[], None]] = None
+    reconfigure_cb: Optional[Callable[[], None]] = None,
+    refresh: bool = False
 ) -> None:
     cmake_cache = os.path.join(build_dir, "CMakeCache.txt")
-    rerun_cmake = args.reconfigure or not os.path.isfile(cmake_cache)
+    has_cache = os.path.isfile(cmake_cache)
 
-    if rerun_cmake:
-        if reconfigure_cb is not None:
-            reconfigure_cb()
-        os.makedirs(build_dir, exist_ok=True)
+    if has_cache and refresh and not args.reconfigure:
+        subprocess.run(["cmake", "."], check=True, cwd=build_dir)
+        return
 
-        generator_args = []
-        if not os.path.isfile(cmake_cache) and shutil.which("ninja"):
-            generator_args = ["-G", "Ninja"]
-
-        subprocess.run(["cmake", "..", *generator_args, *extra_args],
-                       check=True, cwd=build_dir)
-    else:
+    if has_cache and not args.reconfigure:
         print("Not rerunning cmake since build directory already exists "
               "(--reconfigure)")
+        return
+
+    if reconfigure_cb is not None:
+        reconfigure_cb()
+    os.makedirs(build_dir, exist_ok=True)
+
+    generator_args = []
+    if not has_cache and shutil.which("ninja"):
+        generator_args = ["-G", "Ninja"]
 
+    subprocess.run(["cmake", "..", *generator_args, *extra_args],
+                   check=True, cwd=build_dir)
+
+
+def cmake_run_build(build_dir: str) -> None:
     subprocess.run(
         ["cmake", "--build", ".", "-j", str(os.cpu_count()),
          *cmake_native_build_args(build_dir)],
@@ -209,21 +208,49 @@ def cmake_build(
     )
 
 
-def build_ultra(
-    args: argparse.Namespace, build_dir: str
+def cmake_build(args: argparse.Namespace, build_dir: str) -> None:
+    cmake_configure(args, build_dir)
+    cmake_run_build(build_dir)
+
+
+def configure_ultra(
+    args: argparse.Namespace, build_dir: str, refresh: bool = False
 ) -> None:
     def rebuild_toolchain() -> None:
         # Only rerun toolchain builder if reconfigure is not artificial
         if not args.reconfigure:
             build_toolchain(args)
 
-    cmake_build(
+    cmake_configure(
         args, build_dir, [f"-DCONFIG_FILE={args.config}"],
-        rebuild_toolchain
+        rebuild_toolchain, refresh
     )
 
 
-def make_hyper_config(arch: str) -> str:
+def build_ultra(
+    args: argparse.Namespace, build_dir: str
+) -> None:
+    configure_ultra(args, build_dir)
+    cmake_run_build(build_dir)
+
+
+QEMU_HYPER_OPTIONS = """
+cmdline = "log-level=debug earlycon=e9,colored"
+
+# Hardcode a resolution that's good enough for local testing,
+# we don't need a huge QEMU window.
+video-mode:
+    width = 1024
+    height = 768
+"""
+
+IMAGE_TARGETS = {
+    "qemu": QEMU_HYPER_OPTIONS,
+    "baremetal": "",
+}
+
+
+def make_hyper_config(arch: str, target: str) -> str:
     return \
 f"""
 default-entry = ultra-{arch}
@@ -239,15 +266,7 @@ def make_hyper_config(arch: str) -> str:
 page-table:
     levels = 5
     constraint = maximum
-
-cmdline = "log-level=debug earlycon=e9,colored"
-
-# Hardcode a resolution that's good enough for local testing,
-# we don't need a huge QEMU window.
-video-mode:
-    width = 1024
-    height = 768
-
+{IMAGE_TARGETS[target]}
 [ultra-aarch64]
 protocol = ultra
 higher-half-exclusive = true
@@ -269,7 +288,7 @@ def get_kernel_path(execution_node: str, build_dir: str) -> str:
 
 
 def make_hyper_image(
-    br_type: str, fs_type: str, arch: str, build_dir: str,
+    br_type: str, fs_type: str, arch: str, target: str, build_dir: str,
     hyper_installer: Optional[str], hyper_iso_br: Optional[str],
     hyper_uefi_binaries: List[str], image_path: str, force_regenerate: bool
 ) -> Optional[ultr.DiskImage]:
@@ -290,7 +309,7 @@ def make_hyper_image(
 
     return ultr.DiskImage(
         image_root_path, br_type, fs_type,
-        hyper_config=make_hyper_config(arch),
+        hyper_config=make_hyper_config(arch, target),
         hyper_uefi_binary_paths=hyper_uefi_binaries,
         hyper_iso_br_path=hyper_iso_br,
         hyper_installer_path=hyper_installer,
@@ -454,6 +473,7 @@ def run_lint(args: argparse.Namespace, build_dir: str) -> int:
     if args.toolchain != "clang":
         sys.exit("--lint only works with --toolchain clang")
 
+    configure_ultra(args, build_dir, refresh=True)
     return lint.run(build_dir)
 
 
@@ -465,44 +485,6 @@ def run_unit_tests(args: argparse.Namespace, this_os: str) -> int:
     return subprocess.run([binary]).returncode
 
 
-def root_kconfig() -> kc.Kconfig:
-    with enter_work_dir(pg.project_root()):
-        kconfig = kc.Kconfig(pg.project_root_relative("Kconfig"))
-
-    return kconfig
-
-
-def make_config_from_preset(
-    preset: str, out_path: str, toolchain: str, arch: str
-) -> str:
-    kconfig = root_kconfig()
-    kconfig.load_config(preset)
-
-    preset_arch = kconfig.syms["ARCH_STRING"].str_value
-    if arch != "auto" and arch != preset_arch:
-        sys.exit(f"--arch {arch} conflicts with {preset}, "
-                 f"which is for {preset_arch}")
-
-    toolchain_sym = kconfig.syms[TOOLCHAIN_TO_CONFIG_KEY[toolchain]]
-    preset_toolchain = toolchain_sym.choice.user_selection
-
-    if preset_toolchain is not None and preset_toolchain is not toolchain_sym:
-        print(f"Ignoring {preset_toolchain.name} from {preset}, "
-              f"building with --toolchain {toolchain}")
-
-    toolchain_sym.set_value("y")
-    kconfig.write_config(out_path)
-
-    return preset_arch
-
-
-def make_default_config(out_path: str, toolchain: str, arch: str) -> None:
-    kconfig = root_kconfig()
-    kconfig.syms[TOOLCHAIN_TO_CONFIG_KEY[toolchain]].set_value("y")
-    kconfig.syms[ARCH_TO_CONFIG_KEY[arch]].set_value("y")
-    kconfig.write_config(out_path)
-
-
 def main() -> None:
     ww.relaunch_in_wsl_if_windows()
     pg.set_project_root(os.path.dirname(os.path.abspath(__file__)))
@@ -512,13 +494,15 @@ def main() -> None:
     )
 
     build = parser.add_argument_group("Build")
-    build.add_argument("--arch", default="auto",
-                       choices=["auto", "x86_64", "aarch64"],
-                       help="CPU architecture to build the kernel for "
-                            "(auto implies x86_64 or the config setting if "
-                            "--config is specified)")
+    build.add_argument("--arch", default="x86_64",
+                       choices=["x86_64", "aarch64"],
+                       help="CPU architecture to build the kernel for")
     build.add_argument("--config",
-                       help="Configuration file to use for this build")
+                       help="Preset from configs/ or a config file to build "
+                            f"(default: {cl.DEFAULT_PRESET})")
+    build.add_argument("--reset-config", action="store_true",
+                       help="Recreate the build directory's config from "
+                            "--config, discarding the changes made to it")
     build.add_argument("--menuconfig", action="store_true",
                        help="Run menuconfig to edit the current config file")
     build.add_argument("--guiconfig", action="store_true",
@@ -536,8 +520,11 @@ def main() -> None:
                            help="Build the toolchain and exit")
 
     image = parser.add_argument_group("Image")
-    image.add_argument("--make-image", action="store_true",
-                       help="Produce a bootable image after building")
+    image.add_argument("--make-image", nargs="?", const="qemu",
+                       choices=IMAGE_TARGETS.keys(), metavar="TARGET",
+                       help="Produce a bootable image after building, "
+                            "for QEMU or for real hardware with "
+                            "'baremetal' (default: qemu)")
     image.add_argument("--image-type", choices=["iso", "raw"], default="iso",
                        help="Image type to produce (with --make-image)")
     image.add_argument("--hyper-installer", type=str,
@@ -586,7 +573,7 @@ def main() -> None:
     tests.add_argument("--unit-tests", action="store_true",
                        help="Run the userspace test suite")
     tests.add_argument("--lint", action="store_true",
-                       help="Check the coding conventions after building,"
+                       help="Check the coding conventions without building,"
                             " needs the clang toolchain")
 
     args = parser.parse_args()
@@ -603,35 +590,24 @@ def main() -> None:
     if rc is not None:
         sys.exit(rc)
 
-    if args.config:
-        if not os.path.isfile(args.config):
-            raise RuntimeError(f"Invalid --config path: {args.config}")
-
-        preset_name = os.path.splitext(os.path.basename(args.config))[0]
-        if preset_name.startswith("."):
-            preset_name = "user-config"
+    config_layers = cl.build_layers(args.config, args.arch)
+    config_file = config_layers[-1]
+    default_preset = cl.preset_path(cl.DEFAULT_PRESET)
+    build_dir_name = f"build-{args.toolchain}-{args.arch}"
 
-        build_dir = pg.project_root_relative(
-            f"build-{args.toolchain}-{preset_name}"
-        )
-        os.makedirs(build_dir, exist_ok=True)
+    if os.path.abspath(config_file) != os.path.abspath(default_preset):
+        config_name = os.path.splitext(os.path.basename(config_file))[0]
+        if config_name.startswith("."):
+            config_name = "user-config"
 
-        config = os.path.join(build_dir, ".config")
-        args.arch = make_config_from_preset(args.config, config,
-                                            args.toolchain, args.arch)
-        args.config = config
-    else:
-        if args.arch == "auto":
-            args.arch = "x86_64"
+        build_dir_name += f"-{config_name}"
 
-        build_dir = pg.project_root_relative(
-            f"build-{args.toolchain}-{args.arch}"
-        )
-        os.makedirs(build_dir, exist_ok=True)
+    build_dir = pg.project_root_relative(build_dir_name)
+    os.makedirs(build_dir, exist_ok=True)
 
-        args.config = os.path.join(build_dir, ".config")
-        if not os.path.isfile(args.config):
-            make_default_config(args.config, args.toolchain, args.arch)
+    args.config = os.path.join(build_dir, ".config")
+    cl.prepare_config(args.config, config_layers, args.toolchain,
+                      args.arch, args.reset_config)
 
     if args.menuconfig or args.guiconfig:
         os.environ["KCONFIG_CONFIG"] = args.config
@@ -642,19 +618,19 @@ def main() -> None:
         module = mc if args.menuconfig else gc
 
         with enter_work_dir(pg.project_root()):
-            module.menuconfig(root_kconfig())
+            module.menuconfig(cl.root_kconfig())
         sys.exit(0)
 
     if args.toolchain_only:
         build_toolchain(args)
         sys.exit(0)
 
-    if not args.no_build:
-        build_ultra(args, build_dir)
-
     if args.lint:
         sys.exit(run_lint(args, build_dir))
 
+    if not args.no_build:
+        build_ultra(args, build_dir)
+
     rc = bmc.run_from_args(args, args.arch,
                            get_kernel_path(args.arch, build_dir), build_dir)
     if rc is not None:
@@ -667,6 +643,11 @@ def main() -> None:
     if args.run_for is not None and is_debug:
         sys.exit("--run-for cannot be combined with a debug run")
 
+    image_target = args.make_image or "qemu"
+    if should_run and image_target != "qemu":
+        sys.exit(f"--make-image {image_target} cannot be combined "
+                 "with a QEMU run")
+
     if should_run or args.make_image:
         hyper_installer = args.hyper_installer
         hyper_iso_br = args.hyper_iso_loader
@@ -674,10 +655,15 @@ def main() -> None:
 
         if args.image_type == "iso":
             fs_type = "ISO9660"
-            image_name = "image.iso"
+            image_ext = "iso"
         else:
             fs_type = "FAT32"
-            image_name = "image.raw"
+            image_ext = "raw"
+
+        image_name = "image"
+        if image_target != "qemu":
+            image_name += f"-{image_target}"
+        image_name += f".{image_ext}"
 
         if not hyper_installer:
             hyper_installer = hyper_get_installer()
@@ -696,9 +682,9 @@ def main() -> None:
         image_path = os.path.join(build_dir, image_name)
 
         make_hyper_image(
-            "MBR", fs_type, args.arch, build_dir,
+            "MBR", fs_type, args.arch, image_target, build_dir,
             hyper_installer, hyper_iso_br, hyper_uefi_binary_paths,
-            image_path, args.make_image
+            image_path, args.make_image is not None
         )
 
     if should_run:
diff --git a/configs/arch/x86_64/base.config b/configs/arch/x86_64/base.config
new file mode 100644
index 00000000..7d38e833
--- /dev/null
+++ b/configs/arch/x86_64/base.config
@@ -0,0 +1,2 @@
+CONFIG_PARAVIRT=y
+CONFIG_FLANTERM_CONSOLE=y
diff --git a/configs/debug-lite.config b/configs/debug-lite.config
new file mode 100644
index 00000000..3559c0fa
--- /dev/null
+++ b/configs/debug-lite.config
@@ -0,0 +1,2 @@
+CONFIG_DEBUG_MM=y
+CONFIG_UBSAN=y
diff --git a/configs/release.config b/configs/release.config
new file mode 100644
index 00000000..2cedb6f1
--- /dev/null
+++ b/configs/release.config
@@ -0,0 +1,2 @@
+CONFIG_LTO=y
+CONFIG_OPTIMIZATION_LEVEL=3
diff --git a/kernel/CMakeLists.txt b/kernel/CMakeLists.txt
index 1ff2318a..4fe9de85 100644
--- a/kernel/CMakeLists.txt
+++ b/kernel/CMakeLists.txt
@@ -1,3 +1,4 @@
+include(CheckCCompilerFlag)
 include(symbols.cmake)
 include(free_after_init.cmake)
 include(build_stamp.cmake)
@@ -33,24 +34,44 @@ set(
     ${ULTRA_KERNEL_BASE}
 )
 
-if (CONFIG_ARCH_UNKNOWN_BIT_WIDTH)
-        message(
+if (CONFIG_ARCH_64BIT AND CONFIG_ARCH_32BIT)
+    message(
+        FATAL_ERROR
+        "Please fix your architecture's Kconfig to specify only one bitness"
+    )
+elseif (NOT CONFIG_ARCH_WIDTH)
+    message(
         FATAL_ERROR
-        "Please fix your achitecture's Kconfig to specify bitness"
+        "Please fix your architecture's Kconfig to specify bitness"
     )
 endif ()
 
-if (CONFIG_ARCH_LITTLE_ENDIAN)
+if (CONFIG_ARCH_LITTLE_ENDIAN AND CONFIG_ARCH_BIG_ENDIAN)
+    message(
+        FATAL_ERROR
+        "Please fix your architecture's Kconfig to specify only one "
+        "endianness"
+    )
+elseif (CONFIG_ARCH_LITTLE_ENDIAN)
     ultra_compile_definitions(ULTRA_ARCH_LITTLE_ENDIAN)
 elseif (CONFIG_ARCH_BIG_ENDIAN)
     ultra_compile_definitions(ULTRA_ARCH_BIG_ENDIAN)
 else ()
     message(
         FATAL_ERROR
-        "Please fix your achitecture's Kconfig to specify endianness"
+        "Please fix your architecture's Kconfig to specify endianness"
     )
 endif ()
 
+if (NOT CONFIG_PAGE_SHIFT)
+    message(
+        FATAL_ERROR
+        "Please fix your architecture's Kconfig to select a page size"
+    )
+endif ()
+
+math(EXPR ULTRA_PAGE_SIZE "1 << ${CONFIG_PAGE_SHIFT}")
+
 ultra_compile_definitions(
     ULTRA_ARCH_WIDTH=${CONFIG_ARCH_WIDTH}
     ULTRA_ARCH_PHYS_ADDR_WIDTH=${CONFIG_ARCH_PHYS_ADDR_WIDTH}
@@ -115,8 +136,14 @@ ultra_compile_options(
     -Wimplicit-fallthrough
     -fomit-frame-pointer
     -Wdate-time
+    -Wundef
 )
 
+check_c_compiler_flag(-Wformat-signedness HAVE_FORMAT_SIGNEDNESS)
+if (HAVE_FORMAT_SIGNEDNESS)
+    ultra_compile_options(-Wformat-signedness)
+endif ()
+
 if (CONFIG_LTO)
     ultra_compile_options(${ULTRA_TOOLCHAIN_LTO_FLAGS})
 endif ()
diff --git a/kernel/arch/Kconfig b/kernel/arch/Kconfig
index 870f819c..0a5a6b8a 100644
--- a/kernel/arch/Kconfig
+++ b/kernel/arch/Kconfig
@@ -5,10 +5,6 @@ config ARCH_LITTLE_ENDIAN
 config ARCH_BIG_ENDIAN
     bool
 
-config ARCH_UNKNOWN_ENDIAN
-    bool
-    default y if !ARCH_LITTLE_ENDIAN && !ARCH_BIG_ENDIAN
-
 # Arch bitness settings
 config ARCH_64BIT
     bool
@@ -16,10 +12,6 @@ config ARCH_64BIT
 config ARCH_32BIT
     bool
 
-config ARCH_UNKNOWN_BIT_WIDTH
-    bool
-    default y if !ARCH_64BIT && !ARCH_32BIT
-
 config ARCH_WIDTH
     int
     default 8 if ARCH_64BIT
@@ -36,6 +28,31 @@ config ARCH_PHYS_ADDR_WIDTH
 config ARCH_HAS_UBSAN
     bool
 
+config ARCH_HAS_PAGE_SIZE_4K
+    bool
+
+choice
+    prompt "Page size"
+
+    config PAGE_SIZE_4K
+        bool "4KiB"
+        depends on ARCH_HAS_PAGE_SIZE_4K
+endchoice
+
+config PAGE_SHIFT
+    int
+    default 12 if PAGE_SIZE_4K
+
+# Declared here so the symbol always exists as an int. An arch with
+# a different cache line size gives it a default of its own.
+config ARCH_CACHE_LINE_SHIFT
+    int
+
+config CACHE_LINE_SHIFT
+    int
+    default ARCH_CACHE_LINE_SHIFT if ARCH_CACHE_LINE_SHIFT > 0
+    default 6
+
 if ARCH_X86_64
 rsource "x86_64/Kconfig"
 endif
diff --git a/kernel/arch/aarch64/CMakeLists.txt b/kernel/arch/aarch64/CMakeLists.txt
index bfeb4828..cbac1241 100644
--- a/kernel/arch/aarch64/CMakeLists.txt
+++ b/kernel/arch/aarch64/CMakeLists.txt
@@ -28,5 +28,5 @@ add_ultra_ld_template(
 
 ultra_link_options(
     -T${ULTRA_LD_SCRIPT}
-    -z max-page-size=4096
+    -z max-page-size=${ULTRA_PAGE_SIZE}
 )
diff --git a/kernel/arch/aarch64/Kconfig b/kernel/arch/aarch64/Kconfig
index 16f49cbf..11e32e02 100644
--- a/kernel/arch/aarch64/Kconfig
+++ b/kernel/arch/aarch64/Kconfig
@@ -15,3 +15,4 @@ config ARCH_AARCH64_BASE
     # Big endian mode is not supported
     select ARCH_LITTLE_ENDIAN
     select ARCH_64BIT
+    select ARCH_HAS_PAGE_SIZE_4K
diff --git a/kernel/arch/aarch64/include/arch/constants.h b/kernel/arch/aarch64/include/arch/constants.h
deleted file mode 100644
index e66a0b9c..00000000
--- a/kernel/arch/aarch64/include/arch/constants.h
+++ /dev/null
@@ -1,6 +0,0 @@
-#pragma once
-
-#define PAGE_SIZE 4096
-#define PAGE_SHIFT 12
-
-#define CACHE_LINE_SIZE 64
diff --git a/kernel/arch/x86_64/CMakeLists.txt b/kernel/arch/x86_64/CMakeLists.txt
index a8d5de0c..88060f93 100644
--- a/kernel/arch/x86_64/CMakeLists.txt
+++ b/kernel/arch/x86_64/CMakeLists.txt
@@ -1,7 +1,6 @@
-include(CheckCompilerFlag)
+ultra_sources_no_lto(string.c)
 
 ultra_sources(
-    string.c
     apic.c
     vector_alloc.c
     lapic_domain.c
@@ -28,12 +27,12 @@ ultra_sources(
 )
 ultra_include_directories(include)
 
-check_compiler_flag(
-    C -mpreferred-stack-boundary=4
+check_c_compiler_flag(
+    -mpreferred-stack-boundary=4
     HAVE_PREFERRED_STACK_BOUNDARY
 )
-check_compiler_flag(
-    C -mstack-alignment=16
+check_c_compiler_flag(
+    -mstack-alignment=16
     HAVE_STACK_ALIGNMENT
 )
 
@@ -71,7 +70,7 @@ add_ultra_ld_template(
 
 ultra_link_options(
     -T${ULTRA_LD_SCRIPT}
-    -Wl,-z,max-page-size=4096
+    -Wl,-z,max-page-size=${ULTRA_PAGE_SIZE}
 )
 
 add_subdirectory(hypervisor)
diff --git a/kernel/arch/x86_64/Kconfig b/kernel/arch/x86_64/Kconfig
index 721018ea..5079f6e1 100644
--- a/kernel/arch/x86_64/Kconfig
+++ b/kernel/arch/x86_64/Kconfig
@@ -14,6 +14,7 @@ config ARCH_X86_64_BASE
     bool
     select ARCH_LITTLE_ENDIAN
     select ARCH_64BIT
+    select ARCH_HAS_PAGE_SIZE_4K
     select ARCH_HAS_UBSAN
     select SMBIOS
     select ACPI
diff --git a/kernel/arch/x86_64/cpu.c b/kernel/arch/x86_64/cpu.c
index 0e8c35bb..10f75562 100644
--- a/kernel/arch/x86_64/cpu.c
+++ b/kernel/arch/x86_64/cpu.c
@@ -177,7 +177,7 @@ void INIT_CODE cpu_info_setup(struct x86_cpu_info *info)
     }
 
     if (info != &g_cpu_info) {
-        int i;
+        u32 i;
 
         /*
          * AND our features into the BSP feature table so that it contains the
diff --git a/kernel/arch/x86_64/earlycon.c b/kernel/arch/x86_64/earlycon.c
index bc25070f..3c71ebe5 100644
--- a/kernel/arch/x86_64/earlycon.c
+++ b/kernel/arch/x86_64/earlycon.c
@@ -31,7 +31,7 @@ static struct console s_e9_console = {
     .write = e9_write,
 };
 
-enum ns16550_reg {
+enum ns16550_reg : u32 {
     NS16550_REG_THR = 0,
     NS16550_REG_IER = 1,
     NS16550_REG_FCR = 2,
@@ -165,7 +165,7 @@ static error_t INIT_CODE e9_console_init(bool colored)
     return ret;
 }
 
-enum ns16550_source_kind {
+enum ns16550_source_kind : u32 {
     NS16550_SOURCE_NONE,
     NS16550_SOURCE_IO,
     NS16550_SOURCE_PCI,
@@ -403,7 +403,7 @@ static error_t INIT_CODE ns16550_console_init(
     return EOK;
 }
 
-enum earlycon_mode {
+enum earlycon_mode : u32 {
     EARLYCON_MODE_NONE,
     EARLYCON_MODE_E9,
     EARLYCON_MODE_NS16550,
diff --git a/kernel/arch/x86_64/entry.c b/kernel/arch/x86_64/entry.c
index 5392ea60..8c3fc8f5 100644
--- a/kernel/arch/x86_64/entry.c
+++ b/kernel/arch/x86_64/entry.c
@@ -41,7 +41,7 @@ static error_t INIT_CODE x86_early_init(void)
     cr0_setup();
 
     pr_info(
-        "Running on %s (%d:%d:%d)\n",
+        "Running on %s (%u:%u:%u)\n",
         g_cpu_info.name_string, g_cpu_info.family, g_cpu_info.model,
         g_cpu_info.stepping
     );
diff --git a/kernel/arch/x86_64/exceptions.c b/kernel/arch/x86_64/exceptions.c
index d28700aa..fa061b88 100644
--- a/kernel/arch/x86_64/exceptions.c
+++ b/kernel/arch/x86_64/exceptions.c
@@ -79,13 +79,13 @@ EXCEPTION_HANDLER(X86_EXCEPTION_UD)
 
 EXCEPTION_HANDLER(X86_EXCEPTION_PF)
 {
-    phys_addr_t addr;
+    virt_addr_t addr;
 
     if (handle_abortable_instruction(regs))
         return;
 
     asm volatile("mov %%cr2, %0" : "=r"(addr));
-    panic("Page fault at 0x%016llX", addr);
+    panic("Page fault at 0x%016zX", addr);
 }
 
 bool arch_handle_abortable_instruction(
diff --git a/kernel/arch/x86_64/include/arch/constants.h b/kernel/arch/x86_64/include/arch/constants.h
deleted file mode 100644
index a601e5c3..00000000
--- a/kernel/arch/x86_64/include/arch/constants.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#pragma once
-
-#ifndef __ASSEMBLER__
-#include <common/types.h>
-
-extern u8 g_max_phys_bits;
-#define MAX_PHYS_BITS g_max_phys_bits
-#endif
-
-#define PAGE_SIZE 4096
-#define PAGE_SHIFT 12
-
-#define CACHE_LINE_SIZE 64
diff --git a/kernel/arch/x86_64/include/arch/memory.h b/kernel/arch/x86_64/include/arch/memory.h
index 38dc239e..1813ec6b 100644
--- a/kernel/arch/x86_64/include/arch/memory.h
+++ b/kernel/arch/x86_64/include/arch/memory.h
@@ -9,3 +9,6 @@ extern virt_addr_t g_memory_map_base, g_memory_map_end;
 extern virt_addr_t g_valloc_base, g_valloc_end;
 #define VALLOC_BASE g_valloc_base
 #define VALLOC_END g_valloc_end
+
+extern u8 g_max_phys_bits;
+#define MAX_PHYS_BITS g_max_phys_bits
diff --git a/kernel/arch/x86_64/include/arch/page_table.h b/kernel/arch/x86_64/include/arch/page_table.h
index e0790ad8..4002f2fd 100644
--- a/kernel/arch/x86_64/include/arch/page_table.h
+++ b/kernel/arch/x86_64/include/arch/page_table.h
@@ -3,7 +3,7 @@
 #include <common/types.h>
 #include <common/bit.h>
 
-#include <arch/constants.h>
+#include <arch_constants.h>
 #include <memory/vm_flags.h>
 #include <memory/io.h>
 
diff --git a/kernel/arch/x86_64/include/arch/private/apic.h b/kernel/arch/x86_64/include/arch/private/apic.h
index a71bbf31..5c84096d 100644
--- a/kernel/arch/x86_64/include/arch/private/apic.h
+++ b/kernel/arch/x86_64/include/arch/private/apic.h
@@ -3,7 +3,7 @@
 #include <common/types.h>
 #include <common/bit.h>
 
-enum apic_reg {
+enum apic_reg : u32 {
     APIC_REG_ID = 0x20,
     APIC_REG_VERSION = 0x30,
     APIC_REG_TPR = 0x80,
@@ -60,7 +60,7 @@ enum apic_reg {
 
 #define APIC_ID_NONE 0xFFFF'FFFF
 
-enum apic_mode {
+enum apic_mode : u32 {
     APIC_MODE_NONE = 0,
     APIC_MODE_X,
     APIC_MODE_X2,
diff --git a/kernel/arch/x86_64/include/arch/private/cpu.h b/kernel/arch/x86_64/include/arch/private/cpu.h
index 113071b6..8d5a6f33 100644
--- a/kernel/arch/x86_64/include/arch/private/cpu.h
+++ b/kernel/arch/x86_64/include/arch/private/cpu.h
@@ -6,7 +6,7 @@
 
 #include <per_cpu.h>
 
-enum x86_feature_dword {
+enum x86_feature_dword : u32 {
     X86_FEATURE_DWORD_1_C = 0,
     X86_FEATURE_DWORD_1_D,
     X86_FEATURE_DWORD_7_B,
@@ -29,7 +29,7 @@ enum x86_feature_dword {
 #define X86_FEATURE_DWORD_BIT(name, bit) \
     ((X86_FEATURE_DWORD_##name * sizeof(u32) * BITS_PER_BYTE) + (bit))
 
-enum x86_feature {
+enum x86_feature : u32 {
     X86_FEATURE_SSE3 = X86_FEATURE_DWORD_BIT(1_C, 0),
     X86_FEATURE_PCLMULQDQ = X86_FEATURE_DWORD_BIT(1_C, 1),
     X86_FEATURE_DTES64 = X86_FEATURE_DWORD_BIT(1_C, 2),
diff --git a/kernel/arch/x86_64/ioapic.c b/kernel/arch/x86_64/ioapic.c
index a62e5957..65cb19cd 100644
--- a/kernel/arch/x86_64/ioapic.c
+++ b/kernel/arch/x86_64/ioapic.c
@@ -4,12 +4,12 @@
 #include <arch/private/irq.h>
 #include <arch/private/apic.h>
 #include <arch/irq.h>
-#include <arch/constants.h>
 
 #include <private/irq.h>
 
 #include <log.h>
 #include <bug.h>
+#include <arch_constants.h>
 #include <init_level.h>
 #include <free_after_init.h>
 #include <spinlock.h>
@@ -28,7 +28,7 @@
 #define IOAPIC_IOWIN 0x10
 #define IOAPIC_EOIR 0x40
 
-enum ioapic_reg {
+enum ioapic_reg : u32 {
     IOAPIC_REG_ID = 0x00,
         #define IOAPIC_ID MAKE_BIT_MASK(31, 24)
 
@@ -143,7 +143,7 @@ static INIT_CODE void irq_resolve_activation(
         break;
     default:
         pr_warn(
-            "invalid polarity value %d for irq %d, assuming active high\n",
+            "invalid polarity value %u for irq %u, assuming active high\n",
             *in_out_polarity, irq
         );
         FALLTHROUGH;
@@ -167,7 +167,7 @@ static INIT_CODE void irq_resolve_activation(
         break;
     default:
         pr_warn(
-            "invalid triggering value %d for irq %d, assuming edge\n",
+            "invalid triggering value %u for irq %u, assuming edge\n",
             *in_out_triggering, irq
         );
         FALLTHROUGH;
@@ -300,10 +300,10 @@ static INIT_CODE bool ioapic_check_collisions(
 
 out_collision:
     pr_warn(
-        "unable to register IOAPIC[%u] (0x%llX, GSI[%u->%u]): "
-        "%s collides with existing IOAPIC[%u] (0x%llX, GSI[%u->%u])\n",
-        ioapic->id, ioapic->base, ioapic->gsi_base, ioapic->gsi_last, which,
-        other->id, other->base, other->gsi_base, other->gsi_last
+        "unable to register IOAPIC[%u] (%8pPA, GSI[%u->%u]): "
+        "%s collides with existing IOAPIC[%u] (%8pPA, GSI[%u->%u])\n",
+        ioapic->id, &ioapic->base, ioapic->gsi_base, ioapic->gsi_last, which,
+        other->id, &other->base, other->gsi_base, other->gsi_last
     );
     return true;
 }
@@ -787,8 +787,8 @@ void INIT_CODE ioapic_register(u8 id, phys_addr_t base, u32 gsi_base)
     spin_lock_init(&new_ioapic->lock);
     s_num_ioapics++;
     pr_info(
-        "registered IOAPIC[%u] (0x%llX, GSI[%u->%u])\n",
-        new_ioapic->id, new_ioapic->base,
+        "registered IOAPIC[%u] (%8pPA, GSI[%u->%u])\n",
+        new_ioapic->id, &new_ioapic->base,
         new_ioapic->gsi_base, new_ioapic->gsi_last
     );
     return;
@@ -797,7 +797,7 @@ void INIT_CODE ioapic_register(u8 id, phys_addr_t base, u32 gsi_base)
     io_window_unmap(&new_ioapic->iow);
 out_no_reg:
     pr_warn(
-        "unable to register IOAPIC[%u] (0x%llX, GSI base %u): %s\n",
-        id, base, gsi_base, why
+        "unable to register IOAPIC[%u] (%8pPA, GSI base %u): %s\n",
+        id, &base, gsi_base, why
     );
 }
diff --git a/kernel/arch/x86_64/smp.c b/kernel/arch/x86_64/smp.c
index da34651d..89f039e7 100644
--- a/kernel/arch/x86_64/smp.c
+++ b/kernel/arch/x86_64/smp.c
@@ -176,7 +176,7 @@ static INIT_CODE error_t register_cpu(u32 apic_id)
 
     if (g_num_present_cpus >= ULTRA_MAX_CPUS) {
         pr_warn(
-            "Skipping CPU 0x%08X, configured MAX_CPUS is 0x%08X\n",
+            "Skipping CPU 0x%08X, configured MAX_CPUS is %d\n",
             apic_id, ULTRA_MAX_CPUS
         );
 
@@ -272,7 +272,7 @@ static INIT_CODE uacpi_iteration_decision detect_isos(
 
     if (unlikely(iso->bus != 0)) {
         pr_warn(
-            "ignoring MADT IRQ %d override for a non-ISA bus %d\n",
+            "ignoring MADT IRQ %u override for a non-ISA bus %u\n",
             iso->source, iso->bus
         );
         return UACPI_ITERATION_DECISION_CONTINUE;
@@ -280,7 +280,7 @@ static INIT_CODE uacpi_iteration_decision detect_isos(
 
     if (unlikely(iso->source >= NUM_ISA_IRQS)) {
         pr_warn(
-            "MADT IRQ %d override outside of ISA range, ignored\n",
+            "MADT IRQ %u override outside of ISA range, ignored\n",
             iso->source
         );
         return UACPI_ITERATION_DECISION_CONTINUE;
diff --git a/kernel/arch/x86_64/x2apic.c b/kernel/arch/x86_64/x2apic.c
index 82103c76..2278640a 100644
--- a/kernel/arch/x86_64/x2apic.c
+++ b/kernel/arch/x86_64/x2apic.c
@@ -2,7 +2,6 @@
 
 #include <arch/private/apic.h>
 #include <arch/private/msr.h>
-#include <arch/constants.h>
 
 #include <common/bit.h>
 
diff --git a/kernel/arch/x86_64/xapic.c b/kernel/arch/x86_64/xapic.c
index b726a455..3aacb912 100644
--- a/kernel/arch/x86_64/xapic.c
+++ b/kernel/arch/x86_64/xapic.c
@@ -2,7 +2,6 @@
 
 #include <arch/private/apic.h>
 #include <arch/private/msr.h>
-#include <arch/constants.h>
 #include <arch/cpu_helpers.h>
 
 #include <irq_helpers.h>
@@ -13,6 +12,7 @@
 
 #include <log.h>
 #include <bug.h>
+#include <arch_constants.h>
 #include <free_after_init.h>
 
 static u64 s_xapic_phys_base;
diff --git a/kernel/common/CMakeLists.txt b/kernel/common/CMakeLists.txt
index 195dfc61..d1ac8a34 100644
--- a/kernel/common/CMakeLists.txt
+++ b/kernel/common/CMakeLists.txt
@@ -4,7 +4,8 @@ ultra_sources(
     ctype.c
     error.c
     format.c
-    string.c
     string_container.c
     rb_tree.c
 )
+
+ultra_sources_no_lto(string.c)
diff --git a/kernel/common/format.c b/kernel/common/format.c
index 22d78824..35975bf5 100644
--- a/kernel/common/format.c
+++ b/kernel/common/format.c
@@ -201,6 +201,22 @@ static void write_symbol(
     }
 }
 
+static void write_phys_addr(
+    struct fmt_buf_state *fb_state, struct fmt_spec *fm, phys_addr_t addr
+)
+{
+    if (fm->min_width == 0)
+        fm->min_width = sizeof(phys_addr_t) * 2;
+
+    fm->base = 16;
+    fm->uppercase = true;
+    fm->pad_char = '0';
+    fm->left_justify = false;
+
+    write_cstr(fb_state, "0x");
+    write_integer(fb_state, fm, addr);
+}
+
 static void consume_digits(struct string *fmt, struct string *out_digits)
 {
     out_digits->text = fmt->text;
@@ -215,7 +231,7 @@ static void consume_digits(struct string *fmt, struct string *out_digits)
     }
 }
 
-enum parse_number_mode {
+enum parse_number_mode : u32 {
     PARSE_NUMBER_MODE_MAYBE,
     PARSE_NUMBER_MODE_MUST,
 };
@@ -434,6 +450,11 @@ static MAYBE_NERR(int) do_vsnprintf(
                 continue;
             }
 
+            if (consume(&fmt, STR("PA"))) {
+                write_phys_addr(fb_state, &fm, *va_arg(vlist, phys_addr_t*));
+                continue;
+            }
+
             if (consume(&fmt, STR("PCI"))) {
                 char text[16];
                 struct pci_address *addr;
diff --git a/kernel/common/string.c b/kernel/common/string.c
index a95907d4..d28fb49c 100644
--- a/kernel/common/string.c
+++ b/kernel/common/string.c
@@ -130,4 +130,20 @@ int strcmp(const char *s1, const char *s2)
 }
 #endif
 
+#ifndef ARCH_HAS_CUSTOM_STRNCMP
+#undef strncmp
+int strncmp(const char *s1, const char *s2, size_t count)
+{
+    while (count--) {
+        if (*s1 != *s2 || *s1 == '\0')
+            return (int)(unsigned char)*s1 - (int)(unsigned char)*s2;
+
+        ++s1;
+        ++s2;
+    }
+
+    return 0;
+}
+#endif
+
 #pragma GCC diagnostic pop
diff --git a/kernel/drivers/acpi/acpi.c b/kernel/drivers/acpi/acpi.c
index 2cd1a52d..36967847 100644
--- a/kernel/drivers/acpi/acpi.c
+++ b/kernel/drivers/acpi/acpi.c
@@ -1,8 +1,7 @@
 #include <common/types.h>
 #include <common/attributes.h>
 
-#include <arch/constants.h>
-
+#include <arch_constants.h>
 #include <free_after_init.h>
 #include <init_level.h>
 
diff --git a/kernel/drivers/acpi/uacpi b/kernel/drivers/acpi/uacpi
index e05715b2..fd92d3f3 160000
--- a/kernel/drivers/acpi/uacpi
+++ b/kernel/drivers/acpi/uacpi
@@ -1 +1 @@
-Subproject commit e05715b2e6a3ae913aecdb86f4fd2dba30304e45
+Subproject commit fd92d3f3bdd614afda47d08ff5fc373c6d1e4c27
diff --git a/kernel/drivers/acpi/uacpi_glue.c b/kernel/drivers/acpi/uacpi_glue.c
index b2d37a29..02a25c09 100644
--- a/kernel/drivers/acpi/uacpi_glue.c
+++ b/kernel/drivers/acpi/uacpi_glue.c
@@ -18,7 +18,13 @@ uacpi_status uacpi_kernel_get_rsdp(uacpi_phys_addr *out_rsdp_address)
 
 void *uacpi_kernel_map(uacpi_phys_addr addr, uacpi_size len)
 {
-    return io_window_map_cached(addr, len);
+    void *virt;
+
+    virt = io_window_map_cached(addr, len);
+    if (unlikely(virt == nullptr))
+        return UACPI_MAP_FAILED;
+
+    return virt;
 }
 
 void uacpi_kernel_unmap(void *addr, uacpi_size len)
diff --git a/kernel/drivers/smbios.c b/kernel/drivers/smbios.c
index 4eb50cdb..682e90f3 100644
--- a/kernel/drivers/smbios.c
+++ b/kernel/drivers/smbios.c
@@ -8,6 +8,7 @@
 #include <memory/io.h>
 #include <free_after_init.h>
 #include <init_level.h>
+#include <arch_constants.h>
 
 #include <common/byte_order.h>
 #include <common/string.h>
@@ -76,7 +77,7 @@ static INIT_CODE void smbios3_setup(void *base)
 
     if (unlikely(entry->size < sizeof(struct smbios3_entrypoint) ||
                  entry->size > 0xFF)) {
-        pr_err("invalid entrypoint size %d\n", entry->size);
+        pr_err("invalid entrypoint size %u\n", entry->size);
         return;
     }
 
@@ -117,7 +118,7 @@ static INIT_CODE void smbios2_setup(void *base)
 
     if (unlikely(entry->size < sizeof(struct smbios2_entrypoint) ||
                  entry->size > 0xFF)) {
-        pr_err("invalid entrypoint size %d\n", entry->size);
+        pr_err("invalid entrypoint size %u\n", entry->size);
         return;
     }
 
@@ -415,7 +416,7 @@ static error_t INIT_CODE smbios_setup(void)
     if (!smbios_available())
         return ENXIO;
 
-    pr_info("version %d.%d.%d\n", s_ctx.major, s_ctx.minor, s_ctx.docrev);
+    pr_info("version %u.%u.%u\n", s_ctx.major, s_ctx.minor, s_ctx.docrev);
 
     ret = smbios_for_each(smbios_parse, nullptr);
     if (is_error(ret)) {
@@ -466,7 +467,7 @@ error_t smbios_for_each(smbios_callback cb, void *user)
         hdr = cursor;
         if (unlikely(hdr->size > bytes_left || hdr->size < sizeof(*hdr))) {
             pr_err(
-                "invalid entry[%d]: size %d (with %u bytes left)\n",
+                "invalid entry[%d]: size %u (with %u bytes left)\n",
                 item_idx, hdr->size, bytes_left
             );
             break;
@@ -527,7 +528,7 @@ error_t smbios_for_each(smbios_callback cb, void *user)
 
     if (bytes_left) {
         pr_debug(
-            "table size truncated %d -> %d\n",
+            "table size truncated %u -> %u\n",
             s_ctx.size, s_ctx.size - bytes_left
         );
         s_ctx.size -= bytes_left;
diff --git a/kernel/drivers/time/acpi_pm.c b/kernel/drivers/time/acpi_pm.c
index f02f5822..a5e3f5a9 100644
--- a/kernel/drivers/time/acpi_pm.c
+++ b/kernel/drivers/time/acpi_pm.c
@@ -47,7 +47,7 @@ static error_t pm_timer_init(void)
     if (fadt->hdr.revision >= 3) {
         if (fadt->x_pm_tmr_blk.address_space_id != ACPI_AS_ID_SYS_IO) {
             pr_warn(
-                "timer not in SystemIO: %d\n",
+                "timer not in SystemIO: %u\n",
                 fadt->x_pm_tmr_blk.address_space_id
             );
             return ENOSYS;
@@ -61,7 +61,7 @@ static error_t pm_timer_init(void)
     if (!port)
         return EOK;
 
-    pr_info("at 0x%04X, %d-bit counter\n", port, bitness);
+    pr_info("at 0x%04X, %u-bit counter\n", port, bitness);
 
     ret = io_window_map_pio(port, 4, &s_pm_io);
     if (is_error(ret)) {
diff --git a/kernel/drivers/time/hpet.c b/kernel/drivers/time/hpet.c
index 63485cb9..66bd08d5 100644
--- a/kernel/drivers/time/hpet.c
+++ b/kernel/drivers/time/hpet.c
@@ -11,7 +11,7 @@
 
 #include <common/bit.h>
 
-enum hpet_reg {
+enum hpet_reg : u32 {
     HPET_REG_CAPID = 0x00,
         #define REV_ID MAKE_BIT_MASK(7, 0)
         #define NUM_TIM_CAP MAKE_BIT_MASK(12, 8)
@@ -82,7 +82,7 @@ static error_t hpet_init(void)
     uacpi_table_unref(&tbl);
 
     if (gas.address_space_id != ACPI_AS_ID_SYS_MEM) {
-        pr_warn("timer not in SystemMemory: %d\n", gas.address_space_id);
+        pr_warn("timer not in SystemMemory: %u\n", gas.address_space_id);
         return ENOSYS;
     }
     address = gas.address;
@@ -107,7 +107,7 @@ static error_t hpet_init(void)
         return ENXIO;
     }
 
-    pr_info("at 0x%llX, %d-bit counter\n", address, bitness);
+    pr_info("at %8pPA, %u-bit counter\n", &address, bitness);
 
     config = hpet_read(HPET_REG_CONFIG);
     config |= ENABLE_CNF;
diff --git a/kernel/entry.c b/kernel/entry.c
index b597bc09..a0c7608f 100644
--- a/kernel/entry.c
+++ b/kernel/entry.c
@@ -120,7 +120,7 @@ static error_t INIT_CODE boot_info_init(void)
     );
 
     pr_info(
-        "direct map set at 0x%016zX (%d pt levels)\n",
+        "direct map set at 0x%016zX (%u pt levels)\n",
         g_direct_map_base, pi->page_table_depth
     );
 
diff --git a/kernel/include/arch_constants.h b/kernel/include/arch_constants.h
new file mode 100644
index 00000000..793bdcf0
--- /dev/null
+++ b/kernel/include/arch_constants.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <common/types.h>
+#include <config.h>
+
+#define PAGE_SHIFT CONFIG_PAGE_SHIFT
+#define PAGE_SIZE (LITERAL_OF_TYPE(reg_t, 1) << PAGE_SHIFT)
+
+#define CACHE_LINE_SHIFT CONFIG_CACHE_LINE_SHIFT
+#define CACHE_LINE_SIZE (LITERAL_OF_TYPE(reg_t, 1) << CACHE_LINE_SHIFT)
diff --git a/kernel/include/common/align.h b/kernel/include/common/align.h
index 5cfc3c81..e96f54ca 100644
--- a/kernel/include/common/align.h
+++ b/kernel/include/common/align.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <common/attributes.h>
-#include <arch/constants.h>
+#include <arch_constants.h>
 
 #if HAS_BUILTIN(__builtin_align_up)
     #define ALIGN_UP(x, val) __builtin_align_up(x, val)
diff --git a/kernel/include/common/atomic.h b/kernel/include/common/atomic.h
index 074fe8a7..ec82d8e6 100644
--- a/kernel/include/common/atomic.h
+++ b/kernel/include/common/atomic.h
@@ -1,6 +1,8 @@
 #pragma once
 
-enum memory_order {
+#include <common/types.h>
+
+enum memory_order : u32 {
     MO_RELAXED = __ATOMIC_RELAXED,
     MO_CONSUME = __ATOMIC_CONSUME,
     MO_ACQ_REL = __ATOMIC_ACQ_REL,
diff --git a/kernel/include/common/ctype.h b/kernel/include/common/ctype.h
index 852577f2..969012c9 100644
--- a/kernel/include/common/ctype.h
+++ b/kernel/include/common/ctype.h
@@ -4,7 +4,7 @@
 
 #include <common/types.h>
 
-enum char_type {
+enum char_type : u32 {
     CHAR_TYPE_CONTROL = 1 << 0,
     CHAR_TYPE_SPACE = 1 << 1,
     CHAR_TYPE_BLANK = 1 << 2,
diff --git a/kernel/include/common/string.h b/kernel/include/common/string.h
index 555425b5..8555c440 100644
--- a/kernel/include/common/string.h
+++ b/kernel/include/common/string.h
@@ -10,6 +10,7 @@
 #define strlen __builtin_strlen
 #define strstr __builtin_strstr
 #define strcmp __builtin_strcmp
+#define strncmp __builtin_strncmp
 
 static ALWAYS_INLINE void *memzero(void *dest, size_t count)
 {
diff --git a/kernel/include/common/types.h b/kernel/include/common/types.h
index 6580f4ed..a232399a 100644
--- a/kernel/include/common/types.h
+++ b/kernel/include/common/types.h
@@ -1,12 +1,21 @@
 #pragma once
 
+#include <common/helpers.h>
+
+/*
+ * Typed constants for headers shared with assembly and linker scripts.
+ * LITERAL_OF_TYPE() only takes a number but also works in #if,
+ * CONST_OF_TYPE() takes any expression.
+ */
+#ifdef __ASSEMBLER__
+#define LITERAL_OF_TYPE(type, x) x
+#define CONST_OF_TYPE(type, x) x
+#else
 #include <stddef.h>
 #include <stdint.h>
 #include <stdbool.h>
 #include <limits.h>
 
-#include <common/helpers.h>
-
 // signed types
 typedef int8_t i8;
 typedef int16_t i16;
@@ -28,11 +37,27 @@ typedef reg_t irq_state_t;
 
 #if ULTRA_ARCH_PHYS_ADDR_WIDTH == 4
 typedef u32 phys_addr_t;
-#else
+#define LITERAL_SUFFIX_phys_addr_t LITERAL_SUFFIX_u32
+#elif ULTRA_ARCH_PHYS_ADDR_WIDTH == 8
 typedef u64 phys_addr_t;
+#define LITERAL_SUFFIX_phys_addr_t LITERAL_SUFFIX_u64
+#else
+#error Unsupported ULTRA_ARCH_PHYS_ADDR_WIDTH
 #endif
 
 typedef ptr_t virt_addr_t;
+typedef size_t pfn_t;
+
+#define LITERAL_SUFFIX_i32
+#define LITERAL_SUFFIX_i64 ll
+#define LITERAL_SUFFIX_u32 u
+#define LITERAL_SUFFIX_u64 ull
+#define LITERAL_SUFFIX_ptr_t ul
+#define LITERAL_SUFFIX_reg_t ul
+#define LITERAL_SUFFIX_virt_addr_t LITERAL_SUFFIX_ptr_t
+
+#define LITERAL_OF_TYPE(type, x) CONCAT(x, LITERAL_SUFFIX_##type)
+#define CONST_OF_TYPE(type, x) ((type)(x))
 
 #if !defined(ULTRA_TEST) || defined(_MSC_VER)
 #if UINTPTR_MAX == 0xFFFFFFFF
@@ -55,3 +80,16 @@ BUILD_BUG_ON(sizeof(u32) != 4);
 BUILD_BUG_ON(sizeof(u64) != 8);
 
 BUILD_BUG_ON(sizeof(bool) != 1);
+
+// __builtin_types_compatible_p() does not exist in C++
+#ifndef __cplusplus
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(i32, 1), i32));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(i64, 1), i64));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(u32, 1), u32));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(u64, 1), u64));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(ptr_t, 1), ptr_t));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(reg_t, 1), reg_t));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(virt_addr_t, 1), virt_addr_t));
+BUILD_BUG_ON(!ARE_SAME_TYPE(LITERAL_OF_TYPE(phys_addr_t, 1), phys_addr_t));
+#endif
+#endif
diff --git a/kernel/include/irq.h b/kernel/include/irq.h
index b0273c67..76f1876a 100644
--- a/kernel/include/irq.h
+++ b/kernel/include/irq.h
@@ -68,7 +68,7 @@ struct irq_spec {
     enum irq_trigger trigger;
 };
 
-enum irq_result {
+enum irq_result : u32 {
     IRQ_RESULT_UNHANDLED,
     IRQ_RESULT_HANDLED,
 };
diff --git a/kernel/include/linker_common.ld.h b/kernel/include/linker_common.ld.h
index 649d5e5b..f20c2ac6 100644
--- a/kernel/include/linker_common.ld.h
+++ b/kernel/include/linker_common.ld.h
@@ -2,7 +2,7 @@
 
 #include <linker.h>
 
-#include <arch/constants.h>
+#include <arch_constants.h>
 #include <private/init_level.h>
 
 #define PHDR_READ  (1 << 2)
diff --git a/kernel/include/log.h b/kernel/include/log.h
index b3fe204f..5239b115 100644
--- a/kernel/include/log.h
+++ b/kernel/include/log.h
@@ -2,6 +2,7 @@
 
 #include <common/attributes.h>
 #include <common/helpers.h>
+#include <common/types.h>
 
 #include <stdarg.h>
 
@@ -21,7 +22,7 @@
 #define SYSLOG_DEBUG   7
 #define LOG_LEVEL_CONTINUED 8
 
-enum log_level {
+enum log_level : u32 {
     LOG_LEVEL_EMERG   = SYSLOG_EMERG,
     LOG_LEVEL_ALERT   = SYSLOG_ALERT,
     LOG_LEVEL_CRIT    = SYSLOG_CRIT,
@@ -61,7 +62,7 @@ enum log_level {
 
 // For a level only known at runtime
 #define LOG_LEVEL_FMT LOG_LEVEL_PREFIX "%c"
-#define LOG_LEVEL_ARG(lvl) ('0' + (lvl))
+#define LOG_LEVEL_ARG(lvl) ((char)('0' + (lvl)))
 
 void vprint(const char *msg, va_list vlist);
 
diff --git a/kernel/include/memory/alloc_behavior.h b/kernel/include/memory/alloc_behavior.h
index 228b6a55..fdb8302f 100644
--- a/kernel/include/memory/alloc_behavior.h
+++ b/kernel/include/memory/alloc_behavior.h
@@ -1,6 +1,8 @@
 #pragma once
 
-enum alloc_behavior {
+#include <common/types.h>
+
+enum alloc_behavior : u32 {
     /*
      * Generic kernel allocation, may sleep, use IO, reclaim,
      * retry, or otherwise do things that may cause unpredictable
diff --git a/kernel/include/memory/buddy.h b/kernel/include/memory/buddy.h
index 4a05e3ee..1f3b4b2d 100644
--- a/kernel/include/memory/buddy.h
+++ b/kernel/include/memory/buddy.h
@@ -5,7 +5,7 @@
 #include <common/helpers.h>
 #include <common/bit.h>
 
-#include <arch/constants.h>
+#include <arch_constants.h>
 
 #include <memory/alloc_behavior.h>
 #include <memory/page.h>
diff --git a/kernel/include/memory/io.h b/kernel/include/memory/io.h
index ffde1329..8c010624 100644
--- a/kernel/include/memory/io.h
+++ b/kernel/include/memory/io.h
@@ -4,7 +4,7 @@
 #include <common/error.h>
 #include <common/bit.h>
 
-#include <arch/constants.h>
+#include <arch/memory.h>
 #include <arch/io.h>
 
 #define MAX_PHYS_ADDR BIT_OF_TYPE(phys_addr_t, MAX_PHYS_BITS)
diff --git a/kernel/include/memory/page.h b/kernel/include/memory/page.h
index bebb2a26..5a744748 100644
--- a/kernel/include/memory/page.h
+++ b/kernel/include/memory/page.h
@@ -39,7 +39,7 @@
 
 #include <memory/io.h>
 #include <memory/bug.h>
-#include <arch/constants.h>
+#include <arch_constants.h>
 #include <spinlock.h>
 
 /*
@@ -269,27 +269,34 @@ static inline ptr_t page_to_block_ptr(const struct page *page)
 
 extern struct page *g_memory_map;
 
-#define PHYS_ADDR_TO_PFN(phys_addr) ((phys_addr) >> PAGE_SHIFT)
-#define PFN_TO_PHYS_ADDR(pfn) ((phys_addr_t)(pfn) << PAGE_SHIFT)
+static inline pfn_t phys_to_pfn(phys_addr_t addr)
+{
+    return addr >> PAGE_SHIFT;
+}
+
+static inline phys_addr_t pfn_to_phys(pfn_t pfn)
+{
+    return (phys_addr_t)pfn << PAGE_SHIFT;
+}
 
-static inline struct page *pfn_to_page(phys_addr_t pfn)
+static inline struct page *pfn_to_page(pfn_t pfn)
 {
     return &g_memory_map[pfn];
 }
 
-static inline phys_addr_t page_to_pfn(const struct page *page)
+static inline pfn_t page_to_pfn(const struct page *page)
 {
-    return (phys_addr_t)(page - g_memory_map);
+    return (pfn_t)(page - g_memory_map);
 }
 
 static inline struct page *phys_to_page(phys_addr_t addr)
 {
-    return pfn_to_page(PHYS_ADDR_TO_PFN(addr));
+    return pfn_to_page(phys_to_pfn(addr));
 }
 
 static inline phys_addr_t page_to_phys(const struct page *page)
 {
-    return PFN_TO_PHYS_ADDR(page_to_pfn(page));
+    return pfn_to_phys(page_to_pfn(page));
 }
 
 static inline void *page_to_virt(const struct page *page)
diff --git a/kernel/include/memory/vm_flags.h b/kernel/include/memory/vm_flags.h
index 475eae1e..0792abc6 100644
--- a/kernel/include/memory/vm_flags.h
+++ b/kernel/include/memory/vm_flags.h
@@ -1,6 +1,8 @@
 #pragma once
 
-enum vm_prot {
+#include <common/types.h>
+
+enum vm_prot : u32 {
     VM_PROT_NONE = 0,
     VM_PROT_READ = 1 << 0,
     VM_PROT_WRITE = 1 << 1,
diff --git a/kernel/include/param.h b/kernel/include/param.h
index a14ed167..94788fde 100644
--- a/kernel/include/param.h
+++ b/kernel/include/param.h
@@ -9,7 +9,7 @@
 #include <common/bit.h>
 #include <free_after_init.h>
 
-enum param_flags {
+enum param_flags : u32 {
     /*
      * The value may be changed on a running system, the setter is invoked
      * with is_runtime set to true for such writes. Writing is always a
diff --git a/kernel/include/pci/config_space.h b/kernel/include/pci/config_space.h
index 42dcfb3d..78f07f8b 100644
--- a/kernel/include/pci/config_space.h
+++ b/kernel/include/pci/config_space.h
@@ -8,7 +8,7 @@
 #define PCI_CONFIG_SPACE_SIZE 256
 #define PCIE_CONFIG_SPACE_SIZE 4096
 
-enum pci_config_reg {
+enum pci_config_reg : u32 {
     PCI_CONFIG_VENDOR_ID = 0x00,
         #define PCI_VENDOR_ID_NONE 0xFFFF
 
diff --git a/kernel/include/private/log_ring.h b/kernel/include/private/log_ring.h
index f6d09d95..1a6417f6 100644
--- a/kernel/include/private/log_ring.h
+++ b/kernel/include/private/log_ring.h
@@ -74,7 +74,7 @@ struct log_ring {
     struct log_data_ring data_ring;
 };
 
-enum descriptor_state {
+enum descriptor_state : i32 {
     DESCRIPTOR_STATE_RESERVED  = 0b00,
     DESCRIPTOR_STATE_FREE      = 0b01,
     DESCRIPTOR_STATE_COMMITTED = 0b10,
diff --git a/kernel/include/smbios_structures.h b/kernel/include/smbios_structures.h
index 0354b5f9..bbcc611d 100644
--- a/kernel/include/smbios_structures.h
+++ b/kernel/include/smbios_structures.h
@@ -44,7 +44,7 @@ struct PACKED smbios3_entrypoint {
 EXPECT_SIZEOF(struct smbios3_entrypoint, 0x18);
 
 // smbios_structure_hdr->type
-enum smbios_structure_type {
+enum smbios_structure_type : u32 {
     SMBIOS_STRUCTURE_TYPE_BIOS_INFORMATION = 0,
     SMBIOS_STRUCTURE_TYPE_SYSTEM_INFORMATION = 1,
     SMBIOS_STRUCTURE_TYPE_BOARD_INFORMATION = 2,
diff --git a/kernel/init_level.c b/kernel/init_level.c
index 91ccd491..2218f509 100644
--- a/kernel/init_level.c
+++ b/kernel/init_level.c
@@ -47,7 +47,7 @@ static const struct init_calls INIT_RODATA s_init_calls[] = {
 static enum init_level s_init_level = INIT_LEVEL_NONE;
 static bool s_in_progress = false;
 
-enum init_call_type {
+enum init_call_type : u32 {
     INIT_CALL_TYPE_AT,
     INIT_CALL_TYPE_PRE,
     INIT_CALL_TYPE_POST,
diff --git a/kernel/log.c b/kernel/log.c
index 023175a1..89ac1c17 100644
--- a/kernel/log.c
+++ b/kernel/log.c
@@ -14,11 +14,10 @@
 #include <log_ring.h>
 #include <param.h>
 #include <panic.h>
+#include <arch_constants.h>
 
 #include <time/units.h>
 
-#include <arch/constants.h>
-
 MAKE_LOG_RING(s_log_ring, PAGE_SHIFT + 3, 6);
 
 static const struct suboption_variant s_log_level_variants[] = {
diff --git a/kernel/memory/boot_alloc.c b/kernel/memory/boot_alloc.c
index 1224d653..f12279a4 100644
--- a/kernel/memory/boot_alloc.c
+++ b/kernel/memory/boot_alloc.c
@@ -69,7 +69,7 @@ static INIT_CODE void range_emplace_at(size_t idx, struct memory_range *mr)
     range_insert(mr, idx, s_entry_count++);
 }
 
-enum allow_one_above {
+enum allow_one_above : u32 {
     ALLOW_ONE_ABOVE_NO = 0,
     ALLOW_ONE_ABOVE_YES,
 };
@@ -296,7 +296,7 @@ static INIT_CODE error_t allocate_top_down(
         "invalid allocation size (%zu pages)", page_count
     );
 
-    align = MAX(align, (size_t)PAGE_SIZE);
+    align = MAX(align, PAGE_SIZE);
 
     while (i-- > 0) {
         struct memory_range *mr = &s_buffer[i];
@@ -406,8 +406,8 @@ static INIT_CODE error_t allocate_within(
 
 out_invalid_allocation:
     BUG_WITH_MSG(
-        "invalid allocation: %zu pages within 0x%016llX -> 0x%016llX",
-         page_count, lower_limit, upper_limit
+        "invalid allocation: %zu pages within %pPA -> %pPA",
+         page_count, &lower_limit, &upper_limit
     );
 }
 
@@ -580,14 +580,14 @@ void INIT_CODE boot_free(phys_addr_t address, size_t num_pages)
     };
 
     if (unlikely(!maybe_grow_buffer())) {
-        pr_warn("leaking memory at 0x%016llX (%zu pages)\n", address, num_pages);
+        pr_warn("leaking memory at %pPA (%zu pages)\n", &address, num_pages);
         return;
     }
 
     mr_idx = find_range(address, ALLOW_ONE_ABOVE_NO);
     BUG_ON_WITH_MSG(
-        mr_idx < 0, "invalid free at 0x%016llX (%zu pages)",
-        address, num_pages
+        mr_idx < 0, "invalid free at %pPA (%zu pages)",
+        &address, num_pages
     );
 
     allocate_out_of(mr_idx, &freed_range);
@@ -610,8 +610,7 @@ static void INIT_CODE boot_alloc_add_one(
 
     if (boot_alloc_type == MEMORY_FREE) {
         pr_info(
-            "adding memory 0x%016llX -> 0x%016llX\n",
-            range.physical_address, range.physical_address + MR_SIZE(&range)
+            "adding memory %pPA -> %pPA\n", &start, &end
         );
     }
 
diff --git a/kernel/memory/buddy.c b/kernel/memory/buddy.c
index 33273870..71cf1b2a 100644
--- a/kernel/memory/buddy.c
+++ b/kernel/memory/buddy.c
@@ -52,7 +52,7 @@ static inline void page_set_meta(struct page *page, ptr_t meta)
  */
 static void do_free_block(struct page_block *block)
 {
-    phys_addr_t pfn, buddy_pfn;
+    pfn_t pfn, buddy_pfn;
     struct page *page, *buddy;
     u8 order;
 
@@ -61,7 +61,7 @@ static void do_free_block(struct page_block *block)
     pfn = page_to_pfn(page);
 
     while (order < BUDDY_MAX_ORDER) {
-        buddy_pfn = pfn ^ BIT_PHYS(order);
+        buddy_pfn = pfn ^ BIT(order);
         buddy = pfn_to_page(buddy_pfn);
 
         if (page_meta(buddy) != META_MAKE_BLOCK(PAGE_TYPE_BUDDY, order))
@@ -70,7 +70,7 @@ static void do_free_block(struct page_block *block)
         list_remove(&buddy->buddy.link);
         s_ctx.free_areas[order].num_free--;
 
-        pfn &= ~BIT_PHYS(order);
+        pfn &= ~BIT(order);
         page = pfn_to_page(pfn);
 
         order++;
@@ -91,7 +91,7 @@ static void do_free_block(struct page_block *block)
 static struct page *grab_free_pages(u8 order)
 {
     struct page *page, *buddy;
-    phys_addr_t pfn;
+    pfn_t pfn;
     u8 cur_order;
 
     if (order > BUDDY_MAX_ORDER)
@@ -118,7 +118,7 @@ static struct page *grab_free_pages(u8 order)
     while (cur_order > order) {
         cur_order--;
 
-        buddy = pfn_to_page(pfn + BIT_PHYS(cur_order));
+        buddy = pfn_to_page(pfn + BIT(cur_order));
         page_set_meta(buddy, META_MAKE_BLOCK(PAGE_TYPE_BUDDY, cur_order));
 
         list_insert_next(
@@ -385,12 +385,10 @@ void free_frozen_blocks_bulk(struct page_block **blocks, size_t count)
 }
 
 // Memmap population granularity, see kernel_memory_setup_one()
-#define BUDDY_WINDOW_PAGES PHYS_ADDR_TO_PFN(BUDDY_MAX_SIZE)
-#define INIT_PFN_NONE ((phys_addr_t)-1)
+#define BUDDY_WINDOW_PAGES (BUDDY_MAX_SIZE >> PAGE_SHIFT)
+#define INIT_PFN_NONE ((pfn_t)-1)
 
-static void INIT_CODE zero_memmap_entries(
-    phys_addr_t pfn_start, phys_addr_t pfn_end
-)
+static void INIT_CODE zero_memmap_entries(pfn_t pfn_start, pfn_t pfn_end)
 {
     if (pfn_start >= pfn_end)
         return;
@@ -407,11 +405,9 @@ static void INIT_CODE zero_memmap_entries(
  * ALIGN_DOWN from the next one, whole windows in between are not
  * mapped and must not be touched.
  */
-static void INIT_CODE zero_memmap_gap(
-    phys_addr_t prev_end_pfn, phys_addr_t start_pfn
-)
+static void INIT_CODE zero_memmap_gap(pfn_t prev_end_pfn, pfn_t start_pfn)
 {
-    phys_addr_t hi, lo;
+    pfn_t hi, lo;
 
     hi = MIN(ALIGN_UP(prev_end_pfn, BUDDY_WINDOW_PAGES), start_pfn);
     lo = MAX(ALIGN_DOWN(start_pfn, BUDDY_WINDOW_PAGES), prev_end_pfn);
@@ -444,14 +440,15 @@ static void INIT_CODE init_free_block(struct page *page, u8 order)
 }
 
 // End pfn of the previously walked boot range
-static phys_addr_t INIT_DATA s_init_pfn_cursor;
+static pfn_t INIT_DATA s_init_pfn_cursor;
 
 static void INIT_CODE buddy_init_ram_range(
     phys_addr_t p_start, phys_addr_t p_end, void *ctx_ptr
 )
 {
     struct boot_alloc_for_each_ctx *ctx = ctx_ptr;
-    phys_addr_t pfn_start, pfn_end, p_cur = p_start;
+    phys_addr_t p_cur = p_start;
+    pfn_t pfn_start, pfn_end;
     struct page *page;
     u8 order;
     u64 next_size;
@@ -460,8 +457,8 @@ static void INIT_CODE buddy_init_ram_range(
     MM_BUG_ON(!IS_ALIGNED(p_start, PAGE_SIZE));
     MM_BUG_ON(!IS_ALIGNED(p_end, PAGE_SIZE));
 
-    pfn_start = PHYS_ADDR_TO_PFN(p_start);
-    pfn_end = PHYS_ADDR_TO_PFN(p_end);
+    pfn_start = phys_to_pfn(p_start);
+    pfn_end = phys_to_pfn(p_end);
 
     if (s_init_pfn_cursor == INIT_PFN_NONE) {
         zero_memmap_entries(
diff --git a/kernel/memory/init.c b/kernel/memory/init.c
index 54b90f4e..e5452441 100644
--- a/kernel/memory/init.c
+++ b/kernel/memory/init.c
@@ -92,8 +92,8 @@ static void INIT_CODE do_for_each_memory_map_range(
              * because no sane firmware produces this.
              */
             pr_warn(
-                "skipping out of bounds range 0x%llx-0x%llx (type %u)\n",
-                p_start, p_end, type
+                "skipping out of bounds range %pPA-%pPA (type %u)\n",
+                &p_start, &p_end, type
             );
             continue;
         }
@@ -475,8 +475,8 @@ static void INIT_CODE split_and_map_range(
         size_to_human_short(page_size, &hs);
 
         pr_debug(
-            "  [0x%016llX - 0x%016llX] %zu%c pages\n",
-            mr->start, mr->end, hs.value, *hs.unit
+            "  [%pPA - %pPA] %zu%c pages\n",
+            &mr->start, &mr->end, hs.value, *hs.unit
         );
 
         direct_map_pt5(ctx, mr, prot);
@@ -488,8 +488,8 @@ static void INIT_CODE direct_map_one(
 )
 {
     pr_debug(
-        "direct mapping [0x%016llX - 0x%016llX] as:\n",
-        start, end
+        "direct mapping [%pPA - %pPA] as:\n",
+        &start, &end
     );
     split_and_map_range(
         ctx, start, end, VM_PROT_KERNEL | VM_PROT_READ | VM_PROT_WRITE
@@ -570,6 +570,7 @@ static void INIT_CODE build_kernel_mappings(struct direct_mapping_ctx *ctx)
 static error_t INIT_CODE kernel_address_space_setup(void)
 {
     struct direct_mapping_ctx ctx = { 0 };
+    phys_addr_t max_supported;
 
     ctx.pt = pt_early_page_alloc();
 
@@ -588,10 +589,12 @@ static error_t INIT_CODE kernel_address_space_setup(void)
     );
 
     g_kernel_address_space.pt = ctx.pt;
+
+    max_supported = MAX_PHYS_ADDR;
     pr_lvl(
-        s_max_ram_addr <= MAX_PHYS_ADDR ? LOG_LEVEL_INFO : LOG_LEVEL_WARN,
-        "max RAM address: %llX, max supported: %llX\n",
-        s_max_ram_addr, MAX_PHYS_ADDR
+        s_max_ram_addr <= max_supported ? LOG_LEVEL_INFO : LOG_LEVEL_WARN,
+        "max RAM address: %1pPA, max supported: %1pPA\n",
+        &s_max_ram_addr, &max_supported
     );
     return EOK;
 }
@@ -746,8 +749,8 @@ static void INIT_CODE kernel_memory_setup_one(
     v_end = ALIGN_UP(v_end, PAGE_SIZE);
 
     pr_debug(
-        "populating memmap [0x%016zX/%0llX - 0x%016zX/%0llX]\n",
-        v_start, p_start, v_end, p_end
+        "populating memmap [0x%016zX/%1pPA - 0x%016zX/%1pPA]\n",
+        v_start, &p_start, v_end, &p_end
     );
 
     memory_map_populate_pt5(v_start, v_end);
diff --git a/kernel/memory/io.c b/kernel/memory/io.c
index a2d593e4..853245e1 100644
--- a/kernel/memory/io.c
+++ b/kernel/memory/io.c
@@ -135,7 +135,7 @@ static error_t INIT_CODE early_io_map_init(void)
     }
 
     pr_debug(
-        "early MMIO region at 0x%016zX, slots: %zu of %luK, %zu of %dK\n",
+        "early MMIO region at 0x%016zX, slots: %zu of %zuK, %zu of %dK\n",
         EARLY_IO_MAP_BASE, NUM_EARLY_SMALL_SLOTS, PT1_SIZE / 1024,
         NUM_EARLY_LARGE_SLOTS, NUM_BYTES_PER_LARGE_EARLY_SLOT / 1024
     );
@@ -440,7 +440,7 @@ static void check_access(
 
 out_invalid:
     panic(
-        "Invalid %zu-byte %s IO window [%p len=%zu, type=%d] at %zu: %s",
+        "Invalid %zu-byte %s IO window [%p len=%zu, type=%u] at %zu: %s",
         width, type, iow->mmio_address, iow->length, iow->type, offset, why
     );
 }
diff --git a/kernel/memory/valloc.c b/kernel/memory/valloc.c
index 3e78cd91..6d5f4268 100644
--- a/kernel/memory/valloc.c
+++ b/kernel/memory/valloc.c
@@ -87,7 +87,7 @@ static NORETURN void corrupted_varea(
 )
 {
     panic(
-        "Corrupted varea %p [0x%016zX - 0x%016zX] (type=%d): %s",
+        "Corrupted varea %p [0x%016zX - 0x%016zX] (type=%u): %s",
         area, area->start, area->end, area->type, why
     );
 }
@@ -486,7 +486,7 @@ static struct varea *varea_alloc_within(
     if (align == 0)
         align = PAGE_SIZE;
     BUG_ON(!IS_POWER_OF_TWO(align));
-    align = MAX(align, (size_t)PAGE_SIZE);
+    align = MAX(align, PAGE_SIZE);
 
     size = PAGE_ROUND_UP(size);
     if (unlikely(size == 0))
@@ -1029,7 +1029,7 @@ static void validate_physical_range(
 out_panic:
     panic(
         "attempting to %s() an invalid physical address "
-        "0x%016llX (%zu bytes): %s", caller, start, size, why
+        "%pPA (%zu bytes): %s", caller, &start, size, why
     );
 }
 
diff --git a/kernel/target_helpers.cmake b/kernel/target_helpers.cmake
index 419f30a4..a2ee3ced 100644
--- a/kernel/target_helpers.cmake
+++ b/kernel/target_helpers.cmake
@@ -82,3 +82,14 @@ function(ultra_sources_no_ubsan)
         -fno-sanitize=undefined
     )
 endfunction()
+
+function(ultra_sources_no_lto)
+    ultra_sources(${ARGN})
+    set_property(
+        SOURCE ${ARGN}
+        TARGET_DIRECTORY ${ULTRA_KERNEL_OBJECTS}
+        APPEND
+        PROPERTY COMPILE_OPTIONS
+        -fno-lto
+    )
+endfunction()
diff --git a/kernel/time/counter_device.c b/kernel/time/counter_device.c
index 90f302b5..818a5c8f 100644
--- a/kernel/time/counter_device.c
+++ b/kernel/time/counter_device.c
@@ -114,7 +114,7 @@ static void announce_new_counter(struct counter_device *dev, u64 hz, bool best)
     }
 
     pr_info(
-        "%s @ %s [rated %d], unattended up to %s%s\n",
+        "%s @ %s [rated %u], unattended up to %s%s\n",
         dev->name, freq_str, dev->rating, wrap_str, best ? " [best]" : ""
     );
 }
diff --git a/kernel/unwind.c b/kernel/unwind.c
index 79b4aff7..30201c41 100644
--- a/kernel/unwind.c
+++ b/kernel/unwind.c
@@ -19,7 +19,7 @@
 
 #define DWARF_SP_REG __builtin_dwarf_sp_column()
 
-enum DW_EH_PE {
+enum DW_EH_PE : u32 {
     // The lower 4 bits indicate the format of the data
     DW_EH_PE_absptr = 0x00,
     DW_EH_PE_uleb128 = 0x01,
@@ -130,7 +130,7 @@ static error_t decode_format(
         goto out_copy_data;
 
     default:
-        pr_warn("unhandled DWARF format %d\n", format);
+        pr_warn("unhandled DWARF format %u\n", format);
         return ENOSYS;
     }
 
@@ -178,7 +178,7 @@ static error_t decode_value(
     case DW_EH_PE_funcrel:
     case DW_EH_PE_aligned:
     default:
-        pr_warn("unhandled DWARF scaling %d\n", scaling);
+        pr_warn("unhandled DWARF scaling %u\n", scaling);
         return ENOSYS;
     }
 
@@ -527,7 +527,7 @@ static error_t prepare_unwind_state(struct unwind_state *state)
 #define LOW_6_BITS(x) ((x) & ((1 << 6) - 1))
 #define AS_HIGH_2_BITS_OP(x) ((x) & ~((1 << 6) - 1))
 
-enum dw_cfa_opcode {
+enum dw_cfa_opcode : u32 {
     DW_CFA_nop = 0x00,
     DW_CFA_advance_loc1 = 0x02,
     DW_CFA_advance_loc2 = 0x03,
diff --git a/scripts/check_configs.py b/scripts/check_configs.py
new file mode 100644
index 00000000..7e715c3b
--- /dev/null
+++ b/scripts/check_configs.py
@@ -0,0 +1,162 @@
+import os
+import re
+import tempfile
+from typing import List, Tuple
+
+import scripts.config_layers as cl
+import scripts.kconfiglib.kconfiglib as kc
+
+
+Problem = Tuple[str, int, str]
+ConfigBuild = Tuple[List[str], str, str]
+
+ASSIGNMENT_RE = re.compile(r"^(?:CONFIG_(\w+)=|# CONFIG_(\w+) is not set$)")
+WARNING_RE = re.compile(r"^.*:(\d+): warning: (.*)$")
+
+
+def resolve(
+    kconfig: kc.Kconfig, layers: List[str], arch: str, toolchain: str
+) -> str:
+    kconfig.unset_values()
+    for layer in layers:
+        kconfig.load_config(layer, replace=False)
+
+    kconfig.syms[cl.ARCH_TO_CONFIG_KEY[arch]].set_value("y")
+    kconfig.syms[cl.TOOLCHAIN_TO_CONFIG_KEY[toolchain]].set_value("y")
+
+    return "".join(sym.config_string for sym in kconfig.unique_defined_syms)
+
+
+def is_arch_kconfig(path: str) -> bool:
+    parts = path.split("/")
+    return parts[:2] == ["kernel", "arch"] and len(parts) > 3
+
+
+def builds_for(arch: str, below: List[str]) -> List[ConfigBuild]:
+    return [(below, arch, tc) for tc in cl.TOOLCHAIN_TO_CONFIG_KEY]
+
+
+def line_matters(
+    kconfig: kc.Kconfig, path: str, lines: List[str], i: int,
+    builds: List[ConfigBuild], scratch: str
+) -> bool:
+    without = os.path.join(scratch, "without.config")
+    with open(without, "w") as f:
+        f.write("".join(f"{x}\n" for x in lines[:i] + lines[i + 1:]))
+
+    return any(
+        resolve(kconfig, below + [path], arch, tc) !=
+        resolve(kconfig, below + [without], arch, tc)
+        for below, arch, tc in builds
+    )
+
+
+def check_file(
+    kconfig: kc.Kconfig, path: str, is_preset: bool,
+    builds: List[ConfigBuild], scratch: str
+) -> List[Problem]:
+    problems = []
+    where = os.path.relpath(path, cl.ROOT)
+    reserved = (
+        kconfig.syms[cl.ARCH_TO_CONFIG_KEY["x86_64"]].choice,
+        kconfig.syms[cl.TOOLCHAIN_TO_CONFIG_KEY["clang"]].choice,
+    )
+
+    kconfig.warnings = []
+    kconfig.load_config(path)
+
+    for warning in kconfig.warnings:
+        match = WARNING_RE.match(warning)
+        if match is None:
+            problems.append((where, 1, warning))
+            continue
+
+        problems.append((where, int(match.group(1)), match.group(2)))
+
+    with open(path) as f:
+        lines = f.read().splitlines()
+
+    for i, line in enumerate(lines):
+        match = ASSIGNMENT_RE.match(line)
+        if match is None:
+            continue
+
+        name = match.group(1) or match.group(2)
+        sym = kconfig.syms.get(name)
+        if sym is None or not sym.nodes:
+            continue
+
+        if sym.choice in reserved:
+            problems.append((where, i + 1, f"{name} is chosen by --arch or "
+                                           "--toolchain, not by config "
+                                           "files"))
+            continue
+
+        if is_preset and all(is_arch_kconfig(n.filename) for n in sym.nodes):
+            problems.append((where, i + 1, f"{name} only exists for one "
+                                           "arch, set it in configs/arch/"
+                                           "<arch>/ instead"))
+            continue
+
+        if line_matters(kconfig, path, lines, i, builds, scratch):
+            continue
+
+        problems.append((where, i + 1, f"'{line}' changes nothing for any "
+                                       "arch and toolchain"))
+
+    return problems
+
+
+def stray_arch_files() -> List[Problem]:
+    problems = []
+    arch_root = os.path.join(cl.ROOT, "configs", "arch")
+
+    for arch in sorted(os.listdir(arch_root)):
+        for name in sorted(os.listdir(os.path.join(arch_root, arch))):
+            where = f"configs/arch/{arch}/{name}"
+
+            if arch not in cl.ARCH_TO_CONFIG_KEY:
+                problems.append((where, 1, f"{arch} is not a known arch"))
+                continue
+
+            if name != "base.config":
+                problems.append((where, 1, "only base.config is currently "
+                                           "supported in an arch directory"))
+
+    return problems
+
+
+def check_all(kconfig: kc.Kconfig, scratch: str) -> List[Problem]:
+    problems = stray_arch_files()
+    preset_builds: List[ConfigBuild] = []
+
+    for arch in cl.ARCH_TO_CONFIG_KEY:
+        base = cl.arch_base_config(arch)
+        if base is None:
+            preset_builds.extend(builds_for(arch, []))
+            continue
+
+        preset_builds.extend(builds_for(arch, [base]))
+        problems.extend(check_file(kconfig, base, False,
+                                   builds_for(arch, []), scratch))
+
+    configs_dir = os.path.join(cl.ROOT, "configs")
+    for name in sorted(os.listdir(configs_dir)):
+        if not name.endswith(".config"):
+            continue
+
+        problems.extend(check_file(kconfig, os.path.join(configs_dir, name),
+                                   True, preset_builds, scratch))
+
+    return problems
+
+
+def check() -> List[Problem]:
+    kconfig = cl.root_kconfig()
+    kconfig.warn_to_stderr = False
+    kconfig.warn_assign_undef = True
+    kconfig.warn_assign_override = False
+    kconfig.warn_assign_redun = False
+
+    with tempfile.TemporaryDirectory() as scratch:
+        return check_all(kconfig, scratch)
diff --git a/scripts/config_layers.py b/scripts/config_layers.py
new file mode 100644
index 00000000..0a973553
--- /dev/null
+++ b/scripts/config_layers.py
@@ -0,0 +1,296 @@
+import hashlib
+import os
+import sys
+from typing import Dict, List, Optional, Set
+
+import scripts.kconfiglib.kconfiglib as kc
+
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+ARCH_TO_CONFIG_KEY = {
+    "x86_64": "ARCH_X86_64",
+    "aarch64": "ARCH_AARCH64",
+}
+
+DEFAULT_PRESET = "debug-lite"
+
+TOOLCHAIN_TO_CONFIG_KEY = {
+    "clang": "TOOLCHAIN_CLANG",
+    "gcc": "TOOLCHAIN_GCC",
+}
+
+MERGE_BASE = ".config.merge-base"
+MERGE_BASE_LAYER = "# layer: "
+
+
+def root_kconfig() -> kc.Kconfig:
+    old_dir = os.getcwd()
+    os.chdir(ROOT)
+    try:
+        kconfig = kc.Kconfig(os.path.join(ROOT, "Kconfig"))
+    finally:
+        os.chdir(old_dir)
+
+    return kconfig
+
+
+def load_layers(
+    layers: List[str], toolchain: str, arch: str
+) -> kc.Kconfig:
+    kconfig = root_kconfig()
+    kconfig.warn_assign_undef = True
+    kconfig.warn_assign_override = False
+    kconfig.warn_assign_redun = False
+
+    arch_sym = kconfig.syms[ARCH_TO_CONFIG_KEY[arch]]
+    toolchain_sym = kconfig.syms[TOOLCHAIN_TO_CONFIG_KEY[toolchain]]
+
+    for layer in layers:
+        kconfig.load_config(layer, replace=False)
+
+        layer_arch = arch_sym.choice.user_selection
+        if layer_arch is not None and layer_arch is not arch_sym:
+            sys.exit(f"{layer} selects {layer_arch.name}, which conflicts "
+                     f"with --arch {arch}")
+
+        layer_tc = toolchain_sym.choice.user_selection
+        if layer_tc is not None and layer_tc is not toolchain_sym:
+            print(f"Ignoring {layer_tc.name} from {layer}, "
+                  f"building with --toolchain {toolchain}")
+
+        arch_sym.choice.unset_value()
+        toolchain_sym.choice.unset_value()
+
+    arch_sym.set_value("y")
+    toolchain_sym.set_value("y")
+
+    return kconfig
+
+
+def preset_path(preset: str) -> str:
+    return os.path.join(ROOT, "configs", f"{preset}.config")
+
+
+def preset_config(preset: str) -> str:
+    if os.path.isfile(preset):
+        return preset
+
+    path = preset_path(preset)
+    if os.path.isfile(path):
+        return path
+
+    presets = sorted(
+        os.path.splitext(name)[0]
+        for name in os.listdir(os.path.join(ROOT, "configs"))
+        if name.endswith(".config")
+    )
+    sys.exit(f"--config {preset} is neither a file nor a preset, "
+             f"presets: {', '.join(presets)}")
+
+
+def arch_base_config(arch: str) -> Optional[str]:
+    path = os.path.join(ROOT, "configs", "arch", arch, "base.config")
+    if not os.path.isfile(path):
+        return None
+
+    return path
+
+
+def build_layers(config: Optional[str], arch: str) -> List[str]:
+    path = preset_path(DEFAULT_PRESET)
+    if config is not None:
+        path = preset_config(config)
+
+    base = arch_base_config(arch)
+    is_preset = (os.path.dirname(os.path.abspath(path)) ==
+                 os.path.join(ROOT, "configs"))
+    if base is None or not is_preset:
+        return [path]
+
+    return [base, path]
+
+
+def display_path(path: str) -> str:
+    path = os.path.abspath(path)
+    if path.startswith(ROOT + os.sep):
+        return os.path.relpath(path, ROOT)
+
+    return path
+
+
+def config_values(kconfig: kc.Kconfig) -> Dict[str, str]:
+    reserved = (
+        kconfig.syms[ARCH_TO_CONFIG_KEY["x86_64"]].choice,
+        kconfig.syms[TOOLCHAIN_TO_CONFIG_KEY["clang"]].choice,
+    )
+
+    return {
+        sym.name: sym.str_value for sym in kconfig.unique_defined_syms
+        if sym.config_string and sym.choice not in reserved and
+        any(node.prompt for node in sym.nodes)
+    }
+
+
+def layer_setting(layers: List[str], name: str) -> str:
+    for layer in reversed(layers):
+        with open(layer) as f:
+            for line in f.read().splitlines():
+                if (line.startswith(f"CONFIG_{name}=") or
+                   line == f"# CONFIG_{name} is not set"):
+                    return display_path(layer)
+
+    return "the config files"
+
+
+def layer_stamps(layers: List[str]) -> List[str]:
+    stamps = []
+
+    for layer in layers:
+        with open(layer, "rb") as f:
+            digest = hashlib.sha256(f.read()).hexdigest()
+
+        stamps.append(f"{digest} {display_path(layer)}")
+
+    return stamps
+
+
+def read_merge_base_stamps(path: str) -> Optional[List[str]]:
+    if not os.path.isfile(path):
+        return None
+
+    with open(path) as f:
+        return [
+            line[len(MERGE_BASE_LAYER):].rstrip("\n") for line in f
+            if line.startswith(MERGE_BASE_LAYER)
+        ]
+
+
+def write_merge_base(kconfig: kc.Kconfig, stamps: List[str],
+                     path: str) -> None:
+    header = "".join(f"{MERGE_BASE_LAYER}{stamp}\n" for stamp in stamps)
+    kconfig.write_config(path, header=header, save_old=False)
+
+
+def stamp_path(stamp: str) -> str:
+    return stamp.split(" ", 1)[1]
+
+
+def merge_config(
+    config: str, merge_base: str, layered: kc.Kconfig, layers: List[str],
+    toolchain: str, arch: str
+) -> None:
+    where = display_path(config)
+    stamps = layer_stamps(layers)
+    paths = [stamp_path(stamp) for stamp in stamps]
+    new_values = config_values(layered)
+
+    reader = root_kconfig()
+    reader.warn_to_stderr = False
+
+    old_stamps = read_merge_base_stamps(merge_base)
+    if old_stamps is None:
+        old_paths = None
+        base_values = config_values(load_layers([], toolchain, arch))
+    else:
+        old_paths = [stamp_path(stamp) for stamp in old_stamps]
+        reader.load_config(merge_base)
+        base_values = config_values(reader)
+
+    # Leave .config alone when nothing changed, rewriting it would
+    # make cmake reconfigure on every build
+    if old_stamps == stamps and base_values == new_values:
+        return
+
+    reader.load_config(config)
+    cur_values = config_values(reader)
+
+    messages = []
+    if old_paths is None and paths:
+        messages.append(f"now made from {', '.join(paths)}")
+
+    if old_paths is not None and old_paths != paths:
+        added = [path for path in paths if path not in old_paths]
+        removed = [path for path in old_paths if path not in paths]
+        messages.append(f"now made from {', '.join(added) or 'nothing'} "
+                        f"instead of {', '.join(removed) or 'nothing'}")
+
+    conflicts = []
+    wanted: Dict[str, str] = {}
+    kept: Set[str] = set()
+    names = sorted(set(base_values) | set(new_values) | set(cur_values))
+
+    for name in names:
+        base = base_values.get(name)
+        new = new_values.get(name)
+        cur = cur_values.get(name)
+
+        if cur == base or (cur is None and new != base):
+            if new is not None:
+                wanted[name] = new
+            continue
+
+        if cur is None:
+            continue
+
+        wanted[name] = cur
+        kept.add(name)
+        if new in (base, cur, None):
+            continue
+
+        conflicts.append(f"keeping {name}={cur}, "
+                         f"{layer_setting(layers, name)} now gives {new}")
+
+    write_merge_base(layered, stamps, merge_base)
+
+    for name in kept:
+        if wanted[name] != new_values.get(name):
+            layered.syms[name].set_value(wanted[name])
+
+    hidden = []
+    resolved = config_values(layered)
+    applied = len([
+        name for name in names
+        if name not in kept and resolved.get(name) != cur_values.get(name)
+    ])
+
+    for name, value in wanted.items():
+        if resolved.get(name) == value:
+            continue
+
+        depends = kc.expr_str(layered.syms[name].direct_dep)
+        if name in kept:
+            hidden.append(f"your {name}={value} no longer has an effect, "
+                          f"it depends on {depends}")
+            continue
+
+        hidden.append(f"{name}={value} from {layer_setting(layers, name)} "
+                      f"has no effect, it depends on {depends}")
+
+    if applied:
+        changed = [
+            stamp_path(stamp) for stamp in stamps
+            if stamp not in (old_stamps or [])
+        ]
+        changes = "change" if applied == 1 else "changes"
+        messages.append(f"applied {applied} {changes} from "
+                        f"{', '.join(changed) or 'Kconfig'}")
+
+    for message in messages + conflicts + hidden:
+        print(f"{where}: {message}")
+
+    layered.write_config(config)
+
+
+def prepare_config(
+    config: str, layers: List[str], toolchain: str, arch: str, reset: bool
+) -> None:
+    merge_base = os.path.join(os.path.dirname(config), MERGE_BASE)
+    layered = load_layers(layers, toolchain, arch)
+
+    if not reset and os.path.isfile(config):
+        merge_config(config, merge_base, layered, layers, toolchain, arch)
+        return
+
+    write_merge_base(layered, layer_stamps(layers), merge_base)
+    layered.write_config(config)
diff --git a/scripts/kconfiglib b/scripts/kconfiglib
index 3232cf8b..f849d0db 160000
--- a/scripts/kconfiglib
+++ b/scripts/kconfiglib
@@ -1 +1 @@
-Subproject commit 3232cf8ba43aca0da94467c1456dc8796c7622db
+Subproject commit f849d0db56fd7956e803517d4d0b1fd41aff0ca9
diff --git a/scripts/lint.py b/scripts/lint.py
index f8f5cb31..f4e3b28d 100755
--- a/scripts/lint.py
+++ b/scripts/lint.py
@@ -24,6 +24,8 @@ class Context(NamedTuple):
 
 Check = Callable[[Context], List[Finding]]
 
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
 THIRD_PARTY = ("/uacpi/", "/flanterm/", "/boot/ultra_protocol.h")
 GENERATED_SOURCES = ("kernel_symbols", "build_banner")
 SOURCE_SUFFIXES = (".c", ".h", ".S", ".cpp", ".hpp")
@@ -214,11 +216,144 @@ def compiler_command(entry: Dict[str, Any]) -> Optional[List[str]]:
     return command + ["-fsyntax-only", "-w", "-Xclang", "-ast-dump=json"]
 
 
-class VariableScanner:
+Variable = Tuple[Optional[str], int, str, str]
+Located = Tuple[Optional[str], int, str]
+
+
+class ScanResult(NamedTuple):
+    variables: List[Variable]
+    enums: List[Located]
+    formats: List[Located]
+
+
+FORMAT_SPEC = re.compile(
+    r"%(?P<flags>[-+ 0#]*)(?P<width>\*|\d+)?(?:\.(?P<precision>\*|\d+))?"
+    r"(?P<length>hh|h|ll|l|z|j|t|L|q)?(?P<conversion>.)"
+)
+SUPPORTED_LENGTHS = ("", "hh", "h", "ll", "l", "z")
+SUPPORTED_CONVERSIONS = "cspdiouxX"
+
+PRINTF_SOURCE = "kernel/common/format.c"
+
+POINTER_EXTENSIONS = ("RSM", "SM", "S", "E", "PCI", "PA", "V")
+POINTER_EXTENSION_TYPES = {
+    "PA": ("phys_addr_t",),
+    "E": ("error_t",),
+    "S": ("struct string",),
+    "PCI": ("struct pci_address",),
+    "V": ("struct nested_printf",),
+}
+
+SIGNED = "di"
+UNSIGNED = "uxXo"
+SHORT_LENGTHS = ("", "h", "hh")
+
+
+class Rule(NamedTuple):
+    lengths: Tuple[str, ...]
+    conversions: str
+    expected: str
+
+
+INT_RULE = Rule(SHORT_LENGTHS, SIGNED + "c", "%d")
+UINT_RULE = Rule(SHORT_LENGTHS, UNSIGNED, "%u or %X")
+CHAR_RULE = Rule(("",), "cd", "%c or %d")
+U64_RULE = Rule(("ll",), UNSIGNED, "%llu or %llX")
+I64_RULE = Rule(("ll",), SIGNED, "%lld")
+SIZE_RULE = Rule(("z",), UNSIGNED, "%zu or %zX")
+SSIZE_RULE = Rule(("z",), SIGNED, "%zd")
+STRING_RULE = Rule(("",), "sp", "%s")
+PHYS_RULE = Rule((), "", "%pPA with its address")
+ERROR_RULE = Rule((), "", "%pE with its address")
+
+TYPEDEF_RULES = {
+    "phys_addr_t": PHYS_RULE,
+    "error_t": ERROR_RULE,
+    "size_t": SIZE_RULE,
+    "ptr_t": SIZE_RULE,
+    "reg_t": SIZE_RULE,
+    "virt_addr_t": SIZE_RULE,
+    "ssize_t": SSIZE_RULE,
+    "u64": U64_RULE,
+    "i64": I64_RULE,
+    "u32": UINT_RULE,
+    "u16": UINT_RULE,
+    "u8": UINT_RULE,
+    "i32": INT_RULE,
+    "i16": INT_RULE,
+    "i8": INT_RULE,
+    "bool": INT_RULE,
+}
+
+BUILTIN_RULES = {
+    "_Bool": INT_RULE,
+    "char": CHAR_RULE,
+    "signed char": INT_RULE,
+    "short": INT_RULE,
+    "int": INT_RULE,
+    "unsigned char": UINT_RULE,
+    "unsigned short": UINT_RULE,
+    "unsigned int": UINT_RULE,
+    "long": SSIZE_RULE,
+    "unsigned long": SIZE_RULE,
+    "long long": I64_RULE,
+    "unsigned long long": U64_RULE,
+}
+
+CHAR_STRING = re.compile(r"^char( \*|\[\d*\])$")
+COMPUTED = ("BinaryOperator", "ConditionalOperator")
+COMPUTING_UNARY = ("-", "+", "~", "!")
+
+
+def bare_type(name: str) -> str:
+    for qualifier in ("const ", "volatile "):
+        name = name.replace(qualifier, "")
+    return name.strip()
+
+
+def strip_implicit(node: Dict[str, Any]) -> Dict[str, Any]:
+    while node.get("kind") in ("ImplicitCastExpr", "ParenExpr"):
+        node = node["inner"][0]
+    return node
+
+
+def node_types(node: Dict[str, Any]) -> Tuple[str, str]:
+    qual_type = node.get("type", {})
+    sugared = bare_type(qual_type.get("qualType", ""))
+    plain = bare_type(qual_type.get("desugaredQualType", sugared))
+    return sugared, plain
+
+
+def is_computed(node: Dict[str, Any]) -> bool:
+    if node.get("kind") == "UnaryOperator":
+        return node.get("opcode") in COMPUTING_UNARY
+
+    return node.get("kind") in COMPUTED
+
+
+def mentions_type(node: Dict[str, Any], name: str) -> bool:
+    if node.get("kind") == "CStyleCastExpr":
+        return False
+    if (node.get("kind") in ("DeclRefExpr", "MemberExpr") and
+            node_types(node)[0] == name):
+        return True
+
+    return any(
+        mentions_type(child, name) for child in node.get("inner", [])
+        if isinstance(child, dict)
+    )
+
+
+class AstScanner:
     def __init__(self) -> None:
         self.current_file: Optional[str] = None
         self.current_line = 0
-        self.found: List[Tuple[Optional[str], int, str, str]] = []
+        self.variables: List[Variable] = []
+        self.enums: List[Located] = []
+        self.formats: List[Located] = []
+        self.format_functions: Set[str] = set()
+        self.in_printf_source = False
+        self.enum_types: Dict[str, Tuple[str, str]] = {}
 
     # clang omits the file and the line of a location when they repeat the last
     # ones it printed, in document order, so both are carried along here
@@ -241,7 +376,8 @@ def walk(self, node: Dict[str, Any], in_function: bool) -> None:
         where = self.current_file
 
         extent = node.get("range", {})
-        self.note_location(extent.get("begin"))
+        call_line = self.note_location(extent.get("begin"))
+        call_where = self.current_file
         self.note_location(extent.get("end"))
 
         kind = node.get("kind")
@@ -249,29 +385,192 @@ def walk(self, node: Dict[str, Any], in_function: bool) -> None:
             storage = node.get("storageClass")
 
             if storage == "static":
-                self.found.append((where, line, node["name"], "s_"))
+                self.variables.append((where, line, node["name"], "s_"))
             elif not in_function and storage in (None, "extern"):
-                self.found.append((where, line, node["name"], "g_"))
+                self.variables.append((where, line, node["name"], "g_"))
+
+        inner = node.get("inner", [])
+        if kind == "FunctionDecl" and any(
+            child.get("kind") == "FormatAttr" for child in inner
+        ):
+            self.format_functions.add(node.get("name", ""))
+
+        if kind == "EnumDecl" and node.get("inner"):
+            self.note_enum(node, where, line)
+
+        if kind == "CallExpr" and node.get("inner"):
+            self.in_printf_source = (call_where or "").endswith(PRINTF_SOURCE)
+            for message in self.check_call(node["inner"]):
+                self.formats.append((call_where, call_line, message))
 
         for child in node.get("inner", []):
             if isinstance(child, dict):
                 self.walk(child, in_function or kind == "FunctionDecl")
 
+    def note_enum(
+        self, node: Dict[str, Any], where: Optional[str], line: int
+    ) -> None:
+        name = node.get("name")
+        fixed = node.get("fixedUnderlyingType")
+
+        if fixed is None:
+            what = f"enum {name}" if name else "an anonymous enum"
+            self.enums.append((
+                where, line,
+                f"{what} has no type, declare it as "
+                f"enum {name or '<name>'} : <type>"
+            ))
+            return
+
+        if name:
+            sugared = bare_type(fixed.get("qualType", ""))
+            plain = bare_type(fixed.get("desugaredQualType", sugared))
+            self.enum_types[name] = (sugared, plain)
+
+    def type_name(self, sugared: str) -> str:
+        if not sugared.startswith("enum "):
+            return sugared
+
+        fixed = self.enum_types.get(sugared[len("enum "):])
+        if fixed is None:
+            return sugared
+
+        return f"{sugared} : {fixed[0]}"
+
+    def type_rule(self, sugared: str, plain: str) -> Optional[Rule]:
+        if sugared.startswith("enum "):
+            fixed = self.enum_types.get(sugared[len("enum "):])
+            if fixed is None:
+                return BUILTIN_RULES.get(plain)
+            sugared, plain = fixed
+
+        if sugared == "error_t" and self.in_printf_source:
+            return INT_RULE
+        if sugared in TYPEDEF_RULES:
+            return TYPEDEF_RULES[sugared]
+        if CHAR_STRING.match(plain):
+            return STRING_RULE
+
+        return BUILTIN_RULES.get(plain)
+
+    def check_call(self, inner: List[Dict[str, Any]]) -> List[str]:
+        callee = strip_implicit(inner[0])
+        name = callee.get("referencedDecl", {}).get("name")
+        if name not in self.format_functions:
+            return []
+
+        args = [strip_implicit(arg) for arg in inner[1:]]
+        for index, arg in enumerate(args):
+            if arg.get("kind") == "StringLiteral":
+                return self.check_format(arg["value"][1:-1], args[index + 1:])
+
+        return []
+
+    def check_format(
+        self, fmt: str, args: List[Dict[str, Any]]
+    ) -> List[str]:
+        messages = []
+        next_arg = 0
+
+        for match in FORMAT_SPEC.finditer(fmt):
+            spec = match.group(0)
+            conversion = match.group("conversion")
+            if conversion == "%":
+                continue
+
+            length = match.group("length") or ""
+            next_arg += [match.group("width"),
+                         match.group("precision")].count("*")
 
-def scan_translation_unit(
-    entry: Dict[str, Any]
-) -> List[Tuple[Optional[str], int, str, str]]:
+            if (length not in SUPPORTED_LENGTHS or
+                    conversion not in SUPPORTED_CONVERSIONS):
+                messages.append(f"{spec} is currently not supported")
+                next_arg += 1
+                continue
+
+            if next_arg >= len(args):
+                break
+
+            arg = args[next_arg]
+            next_arg += 1
+
+            if conversion == "p":
+                messages.extend(self.check_pointer(fmt, match.end(), arg))
+                continue
+
+            message = self.check_value(spec, length, conversion, arg)
+            if message is not None:
+                messages.append(message)
+
+        return messages
+
+    def check_pointer(
+        self, fmt: str, end: int, arg: Dict[str, Any]
+    ) -> List[str]:
+        extension = next(
+            (ext for ext in POINTER_EXTENSIONS if fmt.startswith(ext, end)),
+            None
+        )
+
+        if extension is None:
+            if end < len(fmt) and fmt[end].isupper():
+                return [f"%p{fmt[end]}... is not a %p extension, use one "
+                        f"of %p{', %p'.join(POINTER_EXTENSIONS)}"]
+            return []
+
+        wanted = POINTER_EXTENSION_TYPES.get(extension)
+        if wanted is None:
+            return []
+
+        sugared = node_types(arg)[0]
+        pointee = sugared[:-1].strip() if sugared.endswith("*") else sugared
+        if pointee in wanted:
+            return []
+
+        return [f"%p{extension} takes a {wanted[0]} *, not {sugared}"]
+
+    def check_value(
+        self, spec: str, length: str, conversion: str, arg: Dict[str, Any]
+    ) -> Optional[str]:
+        sugared, plain = node_types(arg)
+        computed = is_computed(arg)
+
+        if computed and sugared == "phys_addr_t":
+            return (f"{spec} prints an expression of type phys_addr_t, "
+                    f"assign it to a variable and use %pPA, or cast it if "
+                    f"it is not an address")
+        if computed and mentions_type(arg, "phys_addr_t"):
+            return (f"{spec} prints an expression that involves a "
+                    f"phys_addr_t, assign it to a phys_addr_t and use %pPA, "
+                    f"or cast it if it is not an address")
+
+        rule = self.type_rule(sugared, plain)
+        if rule is None:
+            return None
+        if length in rule.lengths and conversion in rule.conversions:
+            return None
+
+        type_name = self.type_name(sugared)
+        if computed:
+            return (f"{spec} prints an expression of type {type_name}, use "
+                    f"{rule.expected} or cast it to the intended type")
+
+        return (f"{spec} gets an argument of type {type_name}, "
+                f"use {rule.expected}")
+
+
+def scan_translation_unit(entry: Dict[str, Any]) -> ScanResult:
     source = entry["file"]
     if not source.endswith(".c") or is_third_party(source):
-        return []
+        return ScanResult([], [], [])
     if any(name in source for name in GENERATED_SOURCES):
-        return []
+        return ScanResult([], [], [])
 
     command = compiler_command(entry)
     if command is None:
         sys.exit(
-            f"{source} was not compiled with clang, the variable name check"
-            " needs a clang build"
+            f"{source} was not compiled with clang, the checks that read the"
+            " AST need a clang build"
         )
 
     proc = subprocess.run(
@@ -280,39 +579,84 @@ def scan_translation_unit(
     if proc.returncode != 0:
         sys.exit(f"cannot parse {source}:\n{proc.stderr}")
 
-    scanner = VariableScanner()
+    scanner = AstScanner()
     scanner.walk(json.loads(proc.stdout), False)
-    return scanner.found
+    return ScanResult(scanner.variables, scanner.enums, scanner.formats)
 
 
-def check_variable_prefixes(ctx: Context) -> List[Finding]:
+@functools.lru_cache(maxsize=None)
+def scan_all(ctx: Context) -> List[ScanResult]:
     database = os.path.join(ctx.build_dir, "compile_commands.json")
     with open(database) as f:
         entries = json.load(f)
 
     with ThreadPoolExecutor(os.cpu_count()) as pool:
-        per_unit = list(pool.map(scan_translation_unit, entries))
+        return list(pool.map(scan_translation_unit, entries))
+
+
+def kernel_path(ctx: Context, where: Optional[str]) -> Optional[str]:
+    if where is None:
+        return None
+
+    path = os.path.relpath(os.path.realpath(where), ctx.root)
+    if not path.startswith("kernel/") or is_third_party(path):
+        return None
 
+    return path
+
+
+def check_variable_prefixes(ctx: Context) -> List[Finding]:
     seen: Set[Finding] = set()
-    for where, line, name, prefix in (v for unit in per_unit for v in unit):
-        if where is None or name.startswith(prefix):
-            continue
 
-        path = os.path.relpath(os.path.realpath(where), ctx.root)
-        if not path.startswith("kernel/") or is_third_party(path):
-            continue
+    for unit in scan_all(ctx):
+        for where, line, name, prefix in unit.variables:
+            path = kernel_path(ctx, where)
+            if path is None or name.startswith(prefix):
+                continue
+
+            kind = "static" if prefix == "s_" else "global"
+            seen.add(Finding(
+                path, line,
+                f"{kind} variable '{name}' must start with {prefix}"
+            ))
+
+    return list(seen)
+
 
-        kind = "static" if prefix == "s_" else "global"
-        seen.add(Finding(
-            path, line, f"{kind} variable '{name}' must start with {prefix}"
-        ))
+def located_findings(
+    ctx: Context, pick: Callable[[ScanResult], List[Located]]
+) -> List[Finding]:
+    seen: Set[Finding] = set()
+
+    for unit in scan_all(ctx):
+        for where, line, message in pick(unit):
+            path = kernel_path(ctx, where)
+            if path is not None:
+                seen.add(Finding(path, line, message))
 
     return list(seen)
 
 
+def check_enum_types(ctx: Context) -> List[Finding]:
+    return located_findings(ctx, lambda unit: unit.enums)
+
+
+def check_formats(ctx: Context) -> List[Finding]:
+    return located_findings(ctx, lambda unit: unit.formats)
+
+
+def check_configs(ctx: Context) -> List[Finding]:
+    from scripts.check_configs import check
+
+    return [Finding(path, line, message) for path, line, message in check()]
+
+
 CHECKS: Dict[str, Check] = {
     "comments": check_comments,
+    "configs": check_configs,
+    "enum-types": check_enum_types,
     "file-end": check_file_end,
+    "formats": check_formats,
     "includes": check_includes,
     "null": check_null,
     "tabs": check_tabs,
@@ -321,8 +665,7 @@ def check_variable_prefixes(ctx: Context) -> List[Finding]:
 
 
 def run(build_dir: str, checks: Optional[List[str]] = None) -> int:
-    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-    ctx = Context(root, os.path.abspath(build_dir))
+    ctx = Context(ROOT, os.path.abspath(build_dir))
 
     findings: List[Finding] = []
     for name in checks or sorted(CHECKS):
@@ -352,6 +695,7 @@ def main() -> None:
                         help="Only run this check, may be repeated")
     args = parser.parse_args()
 
+    sys.path.insert(0, ROOT)
     sys.exit(run(args.build_dir, args.check))
 
 
diff --git a/tests/arg_parser.h b/tests/arg_parser.h
index 80fbf07b..25b82cfe 100644
--- a/tests/arg_parser.h
+++ b/tests/arg_parser.h
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <stdexcept>
 #include <cstring>
+#include <cstdint>
 #include <memory>
 #include <iostream>
 
diff --git a/tests/memory_map.c b/tests/memory_map.c
index 337d4659..e4ce3209 100644
--- a/tests/memory_map.c
+++ b/tests/memory_map.c
@@ -19,7 +19,7 @@
  * stay zeroed, i.e. PAGE_TYPE_RESERVED, so they are never mistaken for
  * free buddies.
  */
-#define MEMORY_MAP_PADDING_PAGES PHYS_ADDR_TO_PFN(BUDDY_MAX_SIZE)
+#define MEMORY_MAP_PADDING_PAGES (BUDDY_MAX_SIZE >> PAGE_SHIFT)
 
 struct page *g_memory_map;
 static uint64_t s_num_pages;
diff --git a/tests/synthetic-include/arch/constants.h b/tests/synthetic-include/arch/constants.h
deleted file mode 100644
index f2ed3c34..00000000
--- a/tests/synthetic-include/arch/constants.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-
-/*
- * Undef first: host headers may leak their own definitions into harness
- * translation units, e.g. the mach headers on arm64 macOS, where the host
- * page size is 16K.
- */
-#undef PAGE_SIZE
-#undef PAGE_SHIFT
-
-#define PAGE_SIZE 4096
-#define PAGE_SHIFT 12
-
-/*
- * The harness physical backing store is tiny, so this only has to be a
- * plausible ceiling for the range checks that consult it. 52 is what x86_64
- * reports with 5-level paging, matching the backend in arch/page_table.h.
- */
-#define MAX_PHYS_BITS 52
diff --git a/tests/synthetic-include/arch/memory.h b/tests/synthetic-include/arch/memory.h
index f750291b..53a09430 100644
--- a/tests/synthetic-include/arch/memory.h
+++ b/tests/synthetic-include/arch/memory.h
@@ -15,3 +15,10 @@ extern phys_addr_t g_memory_map_base, g_memory_map_end;
 extern phys_addr_t g_valloc_base, g_valloc_end;
 #define VALLOC_BASE g_valloc_base
 #define VALLOC_END g_valloc_end
+
+/*
+ * The harness physical backing store is tiny, so this only has to be a
+ * plausible ceiling for the range checks that consult it. 52 is what x86_64
+ * reports with 5-level paging, matching the backend in arch/page_table.h.
+ */
+#define MAX_PHYS_BITS 52
diff --git a/tests/synthetic-include/arch/page_table.h b/tests/synthetic-include/arch/page_table.h
index 44e3b952..8a73629a 100644
--- a/tests/synthetic-include/arch/page_table.h
+++ b/tests/synthetic-include/arch/page_table.h
@@ -3,7 +3,7 @@
 #include <common/types.h>
 #include <common/error.h>
 
-#include <arch/constants.h>
+#include <arch_constants.h>
 #include <memory/io.h>
 
 /*
diff --git a/tests/synthetic-include/arch_constants.h b/tests/synthetic-include/arch_constants.h
new file mode 100644
index 00000000..53c467c3
--- /dev/null
+++ b/tests/synthetic-include/arch_constants.h
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <common/types.h>
+
+/*
+ * Undef first: host headers may leak their own definitions into harness
+ * translation units, e.g. the mach headers on arm64 macOS, where the host
+ * page size is 16K.
+ */
+#undef PAGE_SIZE
+#undef PAGE_SHIFT
+
+#define PAGE_SHIFT 12
+#define PAGE_SIZE (LITERAL_OF_TYPE(reg_t, 1) << PAGE_SHIFT)
diff --git a/tests/synthetic-include/memory/io.h b/tests/synthetic-include/memory/io.h
index 4373d18c..d7ef67fa 100644
--- a/tests/synthetic-include/memory/io.h
+++ b/tests/synthetic-include/memory/io.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include <common/types.h>
-#include <arch/constants.h>
+#include <arch/memory.h>
 
 #include <test_harness.h>
 
diff --git a/tests/test-cases/files.cmake b/tests/test-cases/files.cmake
index ff848761..fb49bd54 100644
--- a/tests/test-cases/files.cmake
+++ b/tests/test-cases/files.cmake
@@ -16,4 +16,5 @@ add_test_cases(
     test_vector_alloc.c
     test_irq.c
     test_conversions.c
+    test_types.c
 )
diff --git a/tests/test-cases/test_allocators.c b/tests/test-cases/test_allocators.c
index 8d4ad665..3dbf898e 100644
--- a/tests/test-cases/test_allocators.c
+++ b/tests/test-cases/test_allocators.c
@@ -525,7 +525,7 @@ TEST_CASE(buddy_init_reserved_gap)
     ASSERT_ORDER_FREE(0, 2);
     ASSERT_ORDER_FREE(1, 0);
 
-    reserved = pfn_to_page(0x1000 >> PAGE_SHIFT);
+    reserved = pfn_to_page(phys_to_pfn(0x1000));
     ASSERT_EQ(page_type(reserved), PAGE_TYPE_RESERVED);
 }
 
diff --git a/tests/test-cases/test_types.c b/tests/test-cases/test_types.c
new file mode 100644
index 00000000..b6142c57
--- /dev/null
+++ b/tests/test-cases/test_types.c
@@ -0,0 +1,39 @@
+#include <common/types.h>
+
+#include <test_harness.h>
+
+#define TEST_SHIFT 40
+
+#if LITERAL_OF_TYPE(u32, 5) != 5
+#error LITERAL_OF_TYPE() is not usable in #if
+#endif
+
+TEST_CASE(literal_of_type_gives_the_type)
+{
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(i32, 1), i32));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(i64, 1), i64));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(u32, 1), u32));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(u64, 1), u64));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(reg_t, 1), reg_t));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(phys_addr_t, 1), phys_addr_t));
+    ASSERT(ARE_SAME_TYPE(LITERAL_OF_TYPE(reg_t, 1) << 3, reg_t));
+}
+
+TEST_CASE(literal_of_type_values)
+{
+    ASSERT_EQ((LITERAL_OF_TYPE(u64, 1) << TEST_SHIFT), 0x10000000000ull);
+    ASSERT_EQ((LITERAL_OF_TYPE(u32, 0xFFFFFFFF) + 1), 0);
+    ASSERT_EQ((~LITERAL_OF_TYPE(u64, 0xFFF)), 0xFFFFFFFFFFFFF000ull);
+    ASSERT_EQ(LITERAL_OF_TYPE(reg_t, TEST_SHIFT), 40);
+    ASSERT_EQ(LITERAL_OF_TYPE(i32, -1), -1);
+}
+
+TEST_CASE(const_of_type_casts)
+{
+    ASSERT(ARE_SAME_TYPE(CONST_OF_TYPE(u8, 1), u8));
+    ASSERT(ARE_SAME_TYPE(CONST_OF_TYPE(reg_t, TEST_SHIFT - 8), reg_t));
+
+    ASSERT_EQ(CONST_OF_TYPE(u8, 0x1FF), 0xFF);
+    ASSERT_EQ(CONST_OF_TYPE(u16, 1 << 4), 16);
+    ASSERT_EQ((CONST_OF_TYPE(u64, 1) << TEST_SHIFT), 0x10000000000ull);
+}
diff --git a/tests/test_harness.cpp b/tests/test_harness.cpp
index aad0228d..59103a3e 100644
--- a/tests/test_harness.cpp
+++ b/tests/test_harness.cpp
@@ -10,7 +10,7 @@
 #endif
 
 /*
- * Included after any host headers so that the synthetic <arch/constants.h>
+ * Included after any host headers so that the synthetic <arch_constants.h>
  * (pulled in here) overrides a possibly leaked host PAGE_SIZE.
  */
 #include <common/align.h>
diff --git a/toolchain/toolchain_clang.cmake b/toolchain/toolchain_clang.cmake
index bfc1e333..aeb59b3f 100644
--- a/toolchain/toolchain_clang.cmake
+++ b/toolchain/toolchain_clang.cmake
@@ -6,7 +6,7 @@ if (APPLE)
         OUTPUT_VARIABLE BREW_LLD_PREFIX
         OUTPUT_STRIP_TRAILING_WHITESPACE
     )
-    set(CMAKE_EXE_LINKER_FLAGS_INIT "-fuse-ld=${BREW_LLD_PREFIX}/bin/ld.lld")
+    set(CMAKE_EXE_LINKER_FLAGS_INIT "--ld-path=${BREW_LLD_PREFIX}/bin/ld.lld")
 
     execute_process(
         COMMAND brew --prefix llvm