Test booting a kernel compiled with lto

Author: phil-opp

Cargo.lock

@@ -23,6 +23,7 @@ members = [
     "tests/test_kernels/map_phys_mem",
     "tests/test_kernels/higher_half",
     "tests/test_kernels/pie",
+    "tests/test_kernels/lto",
 ]
 exclude = ["examples/basic", "examples/test_framework"]
 
@@ -74,6 +75,10 @@ inherits = "release"
 debug = true
 overflow-checks = true
 
+[profile.lto]
+inherits = "release"
+lto = true
+
 [profile.test.package.test_kernel_higher_half]
 rustflags = [
     "-C",

Cargo.toml

@@ -0,0 +1,25 @@
+use std::{path::Path, process::Command};
+
+use bootloader_test_runner::run_test_kernel;
+
+#[test]
+fn basic_boot() {
+    // build test kernel manually to force-enable link-time optimization
+    let mut cmd = Command::new(std::env::var("CARGO").unwrap_or("cargo".into()));
+    cmd.arg("build");
+    cmd.arg("-p").arg("test_kernel_lto");
+    cmd.arg("--target").arg("x86_64-unknown-none");
+    cmd.arg("--profile").arg("lto");
+    let status = cmd.status().unwrap();
+    assert!(status.success());
+
+    let root = env!("CARGO_MANIFEST_DIR");
+    let kernel_path = Path::new(root)
+        .join("target")
+        .join("x86_64-unknown-none")
+        .join("lto")
+        .join("basic_boot");
+    assert!(kernel_path.exists());
+
+    run_test_kernel(kernel_path.as_path().to_str().unwrap());
+}

tests/lto.rs

@@ -0,0 +1,13 @@
+[package]
+name = "test_kernel_lto"
+version = "0.1.0"
+authors = ["Philipp Oppermann <dev@phil-opp.com>"]
+edition = "2018"
+
+[dependencies]
+bootloader_api = { path = "../../../api" }
+x86_64 = { version = "0.14.7", default-features = false, features = [
+    "instructions",
+    "inline_asm",
+] }
+uart_16550 = "0.2.10"

tests/test_kernels/lto/Cargo.toml

@@ -0,0 +1,21 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader_api::{entry_point, BootInfo};
+use core::panic::PanicInfo;
+use test_kernel_lto::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_lto::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

tests/test_kernels/lto/src/bin/basic_boot.rs

@@ -0,0 +1,27 @@
+#![no_std]
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub fn exit_qemu(exit_code: QemuExitCode) -> ! {
+    use x86_64::instructions::{nop, port::Port};
+
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
+
+    loop {
+        nop();
+    }
+}
+
+pub fn serial() -> uart_16550::SerialPort {
+    let mut port = unsafe { uart_16550::SerialPort::new(0x3F8) };
+    port.init();
+    port
+}