Move parsing of ACPI tables into table structures

Move mapping ACPI table memory into common location

.gitignore

@@ -1,3 +1,4 @@
 .rscons*
-/i686-elf-gcc/
+/x86_64-elf-gcc/
 /build/
+/qemu/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "uefi-d"]
+	path = uefi-d
+	url = git://github.com/kubasz/uefi-d

README.md

@@ -0,0 +1,81 @@
+# HOS System Requirements
+
+HOS requires:
+
+* A 64-bit CPU.
+* A UEFI system.
+* 128MB of RAM.
+
+# Building HOS
+
+From the top level of the repository, run:
+
+    ./rscons
+
+If you get errors about missing packages, install the packages and then re-run
+the build command.
+
+# Running HOS
+
+HOS can run on a physical machine, in VirtualBox, or in QEMU.
+
+## Physical Machine
+
+To install HOS to an EFI partition, follow these steps:
+
+1. Copy build/hello/HOS.EFI to EFI partition EFI/HOS.EFI. For example, from Linux:
+
+    sudo cp build/hello/HOS.EFI /boot/efi/EFI/HOS.EFI
+
+2. Register EFI loader for HOS (one time only) with command:
+
+    efibootmgr -c -d /dev/nvme1n1 -p 2 -l '\EFI\HOS.EFI' -L HOS
+
+(Update the -d device parameter and -p partition parameter as appropriate)
+
+3. Set boot order to desired boot order. Exact order will be system dependent. Example:
+
+    efibootmgr -o 2,0,6,5
+
+At this point you should be able to boot HOS from your EFI boot selection menu.
+If you use GRUB, you can optionally create a GRUB boot entry to load HOS.EFI
+with an entry like this:
+
+    menuentry 'HOS' {
+      insmod part_gpt
+      insmod chain
+      set root='(hd0,gpt1)'
+      chainloader /EFI/HOS.EFI
+    }
+
+Just update the root setting for the correction location to your system's EFI
+partition.
+
+## VirtualBox
+
+To create a VM in VirtualBox:
+
+1. Build HOS ("./rscons").
+2. In VirtualBox, select Machine -> New.
+3. Set name to HOS.
+4. Set Type to Other.
+5. Set Version to Other/Unknown (64-bit).
+6. Click Next.
+7. Set memory size to 512 MB.
+8. Click Next.
+9. Select Do not add a virtual hard disk.
+10. Click Create.
+11. From the HOS repository, create a VirtualBox VMDK image with "./rscons mk-vmdk".
+12. Move the HOS.vmdk file generated to the HOS VirtualBox folder.
+13. In VirtualBox Manager, open HOS VM settings.
+14. Under System, check the Enable EFI checkbox.
+15. Under System, change the Chipset to ICH9.
+16. Under Storage, add a hard disk and browse to select the HOS.vmdk file.
+17. To run HOS, either start the VM through VirtualBox or with "./rscons run-vb".
+
+## QEMU
+
+Make sure QEMU is installed (possibly the `qemu-desktop` package). Then:
+
+1. Build HOS ("./rscons").
+2. Run `./rscons run` to run HOS in QEMU.

Rsconscript

@@ -1,104 +1,86 @@
-path_prepend "i686-elf-gcc/bin"
-
-configure do
-  rscons "i686-elf-gcc.rb", "-b", "#{build_dir}/i686-elf-gcc"
-  check_c_compiler "i686-elf-gcc"
-  check_program "genext2fs"
-  check_program "grub-mkstandalone"
-  check_program "mformat", on_fail: "Install the mtools package"
-  check_program "xorriso"
-  check_cfg package: "freetype2", on_fail: "Install libfreetype-dev", use: "freetype"
-end
-
 require "tmpdir"
 
-# EFI (w/ GRUB) partition size (MiB)
-EFI_PART_SIZE = 8
-# HOS partition size (MiB)
-HOS_PART_SIZE = 4
-# Kernel default font size
-KFONT_SIZE = 15
+project_name "HOS"
+path_prepend "x86_64-elf-gcc/bin"
 
-class BiosImage < Builder
+configure do
+  rscons "x86_64-elf-gcc.rb", "-b", "#{build_dir}/x86_64-elf-gcc"
+  check_d_compiler "ldc2", use: "ldc2"
+  check_c_compiler "x86_64-w64-mingw32-gcc", use: "x86_64-w64-mingw32-gcc"
+  check_c_compiler "x86_64-elf-gcc", use: "x86_64-elf-gcc"
+  check_c_compiler
+  check_program "mformat", on_fail: "Install the mtools package"
+  check_program "parted"
+  check_cfg package: "freetype2", on_fail: "Install libfreetype-dev", use: "freetype"
+  sh %w[git submodule update --init]
+end
+
+# Kernel default font size.
+KFONT_SIZE = 18
+
+# One kilobyte.
+KB = 1024
+
+# One megabyte.
+MB = 1024 * 1024
+
+class HulkBinObj < Builder
   def run(options)
-    unless @cache.up_to_date?(@target, nil, @sources, @env)
-      print_run_message("Generating BIOS boot image #{@target}", nil)
-      Dir.mktmpdir do |tmpdir|
-        # Create iso directory.
-        FileUtils.mkdir_p("#{tmpdir}/iso/boot/grub")
-        File.open("#{tmpdir}/iso/boot/grub/grub.cfg", "wb") do |fh|
-          fh.write(<<EOF)
-set default="0"
-set timeout=1
-menuentry "HOS" {
-insmod multiboot2
-multiboot2 /hos.elf
-}
+    @cache.mkdir_p(File.dirname(@target))
+    File.write(@target, <<EOF)
+.section ".rodata"
+.balign 4096
+.global _hulk_bin_start
+_hulk_bin_start:
+.incbin "#{@sources.first}"
+.balign 4096
+.global _hulk_bin_end
+_hulk_bin_end:
 EOF
-        end
-        @sources.each do |source|
-          FileUtils.cp(source, "#{tmpdir}/iso")
-        end
-        # Build bootable GRUB image.
-        system(*%W[grub-mkrescue -o #{@target} #{tmpdir}/iso], err: "#{@env.build_root}/grub-mkrescue.log")
-      end
+    unless @cache.up_to_date?(@target, nil, @sources, @env)
+      print_run_message("Creating HULK binary object <target>#{@target}<reset>", nil)
       @cache.register_build(@target, nil, @sources, @env)
     end
     true
   end
 end
 
-class EfiImage < Builder
+# Create a GPT disk image with an EFI partition containing the EFI image.
+class Image < Builder
   def run(options)
     unless @cache.up_to_date?(@target, nil, @sources, @env)
-      print_run_message("Generating EFI boot image #{@target}", nil)
-      Dir.mktmpdir do |tmpdir|
-        # Build a standalone GRUB.
-        File.open("#{tmpdir}/grub.cfg", "wb") do |fh|
-          fh.write(<<EOF)
-insmod part_gpt
-configfile (hd0,gpt2)/grub.cfg
-EOF
-        end
-        system(*%W[grub-mkstandalone -O x86_64-efi -o #{tmpdir}/BOOTX64.EFI boot/grub/grub.cfg=#{tmpdir}/grub.cfg])
-        # Create EFI partition.
-        system(*%W[dd if=/dev/zero of=#{tmpdir}/efi.part bs=1M count=#{EFI_PART_SIZE}], err: "/dev/null")
-        system(*%W[mformat -i #{tmpdir}/efi.part ::])
-        system(*%W[mmd -i #{tmpdir}/efi.part ::/EFI])
-        system(*%W[mmd -i #{tmpdir}/efi.part ::/EFI/BOOT])
-        system(*%W[mcopy -i #{tmpdir}/efi.part #{tmpdir}/BOOTX64.EFI ::/EFI/BOOT])
-        # Create ext2 HOS partition.
-        FileUtils.mkdir_p("#{tmpdir}/ext2")
-        @sources.each do |source|
-          FileUtils.cp(source, "#{tmpdir}/ext2")
-        end
-        File.open("#{tmpdir}/ext2/grub.cfg", "wb") do |fh|
-          fh.write(<<EOF)
-set default="0"
-set timeout=1
-menuentry "HOS" {
-insmod part_gpt
-insmod multiboot2
-set root=(hd0,gpt2)
-multiboot2 /hos.elf
-}
-EOF
-        end
-        system(*%W[genext2fs -b #{HOS_PART_SIZE * 1024} -d #{tmpdir}/ext2 #{tmpdir}/ext2.part])
-        # Create full disk image.
-        system(*%W[dd if=/dev/zero of=#{@target} bs=1M count=#{EFI_PART_SIZE + HOS_PART_SIZE + 2}], err: "/dev/null")
-        system(*%W[parted -s #{@target} mklabel gpt])
-        system(*%W[parted -s #{@target} mkpart efi 1MiB #{EFI_PART_SIZE + 1}MiB])
-        system(*%W[parted -s #{@target} mkpart hos #{EFI_PART_SIZE + 1}MiB #{EFI_PART_SIZE + HOS_PART_SIZE + 1}MiB])
-        system(*%W[dd if=#{tmpdir}/efi.part of=#{@target} bs=1M seek=1 conv=notrunc], err: "/dev/null")
-        system(*%W[dd if=#{tmpdir}/ext2.part of=#{@target} bs=1M seek=#{1 + EFI_PART_SIZE} conv=notrunc], err: "/dev/null")
-      end
+      print_run_message("Creating disk image <target>#{@target}<reset>", nil)
+      efi_image_size = File.stat(@sources.first).size
+      efi_image_size_mb = (efi_image_size + MB - 1) / MB
+      partition_size_mb = efi_image_size_mb + 1
+      empty_mb = "\0".b * MB
+      File.binwrite(@target, empty_mb * partition_size_mb)
+      system(*%W[mformat -i #{@target} ::])
+      system(*%W[mmd -i #{@target} ::/EFI])
+      system(*%W[mmd -i #{@target} ::/EFI/BOOT])
+      system(*%W[mcopy -i #{@target} #{@sources.first} ::/EFI/BOOT/BOOTX64.EFI])
+      partition_contents = File.binread(@target)
+      disk_image = empty_mb + partition_contents + empty_mb
+      File.binwrite(@target, disk_image)
+      system(*%W[parted --script #{@target} mklabel gpt mkpart HOS fat32 1MiB #{partition_size_mb + 1}MiB])
       @cache.register_build(@target, nil, @sources, @env)
     end
     true
   end
 end
 
+class CheckThreadLocal < Builder
+  def run(options)
+    map_file = File.binread(@sources.first)
+    if map_file =~ /\.(tdata|tbss)\b/
+      $stderr.puts "Error: found thread-local data in #{@sources.first}"
+      false
+    else
+      true
+    end
+  end
+end
+
 class FontGen < Builder
   def run(options)
     if @command
@@ -112,55 +94,152 @@ class FontGen < Builder
   end
 end
 
-class Size < Builder
-  def run(options)
-    if @command
-      finalize_command
-    else
-      @vars["_SOURCES"] = @sources
-      @vars["_TARGET"] = @target
-      command = @env.build_command(%w[${SIZE} ${_SOURCES}], @vars)
-      standard_command("Size <target>#{@target}<reset>", command, stdout: @target)
+fontgen_env = env "fontgen", use: "freetype" do |env|
+  env.Program("^/fontgen", glob("src/fontgen/**/*.c"))
+end
+
+hulk_env = env "hulk", use: %w[ldc2 x86_64-elf-gcc] do |env|
+  env.add_builder(FontGen)
+  env.add_builder(CheckThreadLocal)
+  env.FontGen("^/src/hulk/kfont.d", "font/Hack-Regular.ttf",
+              "fontgen" => fontgen_env.expand("^/fontgen"))
+  env["sources"] = glob("src/hulk/**/*.d")
+  env["sources"] << "^/src/hulk/kfont.d"
+  cpu_attrs = %w[
+    -avx
+    -avx2
+    -avx512bf16
+    -avx512bitalg
+    -avx512bw
+    -avx512cd
+    -avx512dq
+    -avx512er
+    -avx512f
+    -avx512ifma
+    -avx512pf
+    -avx512vbmi
+    -avx512vbmi2
+    -avx512vl
+    -avx512vnni
+    -avx512vp2intersect
+    -avx512vpopcntdq
+    -sse
+    -sse-unaligned-mem
+    -sse2
+    -sse3
+    -sse4.1
+    -sse4.2
+    -sse4a
+    -ssse3
+  ]
+  env["DFLAGS"] += %W[-mtriple=x86_64-unknown-elf -mattr=#{cpu_attrs.join(",")} --betterC -release -O3 --wi --enable-cross-module-inlining -code-model=large]
+  env["D_IMPORT_PATH"] += %w[src]
+  env["D_IMPORT_PATH"] << env.expand("^/src")
+  env["LD"] = "x86_64-elf-gcc"
+  env["LDFLAGS"] += %w[-nostdlib -Tsrc/hulk/hulk.ld -Wl,--gc-sections -Wl,-Map,${_TARGET}.map]
+  env["LDCMD"] = %w[${LD} -o ${_TARGET} ${LDFLAGS} ${_SOURCES} ${LIBDIRPREFIX}${LIBPATH} ${LIBLINKPREFIX}${LIBS}]
+  env["OBJDUMP"] = "x86_64-elf-objdump"
+  env["OBJCOPY"] = "x86_64-elf-objcopy"
+  env.Program("^/hulk.elf", "${sources}")
+  env.produces("^/hulk.elf", "^/hulk.elf.map")
+  env.CheckThreadLocal(:hulk_map_check, "^/hulk.elf.map")
+  env.depends("^/hulk.elf", "src/hulk/hulk.ld")
+  env["SIZE"] = "x86_64-elf-size"
+  env.Size("^/hulk.elf.size", "^/hulk.elf")
+  env.Disassemble("^/hulk.elf.txt", "^/hulk.elf")
+  env.Command("^/hulk.bin", "^/hulk.elf",
+              "CMD" => %W[${OBJCOPY} -O binary ${_SOURCES} ${_TARGET}],
+              "CMD_DESC" => "Convert ELF to binary:")
+  env.add_build_hook do |builder|
+    if builder.target.end_with?(".o")
+      env.Disassemble("#{builder.target}.txt", builder.target)
     end
   end
 end
 
-# FontGen Environment
-fontgen_env = env "fontgen", use: "freetype" do |env|
-  env["CC"] = "gcc"
-  env.Program("^/fontgen.bin", glob("fontgen/**/*.c"))
-end
-
-# Kernel Environment
-kernel_env = env "kernel" do |env|
-  env.add_builder(EfiImage)
-  env.add_builder(BiosImage)
-  env.add_builder(FontGen)
-  env.add_builder(Size)
-  env["OBJDUMP"] = "i686-elf-objdump"
-  env["SIZE"] = "i686-elf-size"
-  env["CCFLAGS"] += %w[-ffreestanding -Wall -O2]
-  env["LDFLAGS"] += %w[-ffreestanding -nostdlib -T src/link.ld]
-  env["LDFLAGS"] += %W[-Wl,-Map,${_TARGET}.map]
-  env["LIBS"] += %w[gcc]
-  env.FontGen("^/kfont/kfont.c", "font/Hack-Regular.ttf",
-             "fontgen" => fontgen_env.expand("^/fontgen.bin"))
-  env.barrier
-  env["CPPPATH"] += ["#{env.build_root}/kfont"]
-  env.Program("^/hos.elf", glob("src/**/*.{S,c}") + ["^/kfont/kfont.c"])
-  env.depends("#{env.build_root}/hos.elf", "src/link.ld")
-  env.Disassemble("^/hos.elf.txt", "^/hos.elf")
-  env.Size("^/hos.elf.size", "^/hos.elf")
-  env.EfiImage("^/hos-efi.img", %w[^/hos.elf])
-  env.BiosImage("^/hos.img", %w[^/hos.elf])
+hello_env = env "hello", use: %w[ldc2 x86_64-w64-mingw32-gcc] do |env|
+  env.add_builder(Image)
+  env.add_builder(CheckThreadLocal)
+  env.add_builder(HulkBinObj)
+  env["sources"] = glob("src/hello/**/*.d")
+  env["sources"] += %w[
+    src/hulk/serial.d
+    src/hulk/writef.d
+  ]
+  env["sources"] += glob("uefi-d/source/**/*.d")
+  env.HulkBinObj("^/hulk_bin.S", hulk_env.expand("^/hulk.bin"))
+  env.Object("^/hulk_bin.o", "^/hulk_bin.S")
+  env.depends("^/hulk_bin.o", hulk_env.expand("^/hulk.bin"))
+  env["sources"] << "^/hulk_bin.o"
+  env["DFLAGS"] += %w[-mtriple=x86_64-unknown-windows-coff --betterC -release -O3 --wi --enable-cross-module-inlining]
+  env["D_IMPORT_PATH"] += %w[src uefi-d/source]
+  env["LD"] = "x86_64-w64-mingw32-gcc"
+  env["LDFLAGS"] += %w[-nostdlib -Wl,-dll -shared -Wl,--subsystem,10 -e efi_main -Wl,-Map,${_TARGET}.map]
+  env["LDCMD"] = %w[${LD} -o ${_TARGET} ${LDFLAGS} ${_SOURCES} ${LIBDIRPREFIX}${LIBPATH} ${LIBLINKPREFIX}${LIBS}]
+  env["OBJDUMP"] = "x86_64-w64-mingw32-objdump"
+  env.Program("^/HOS.EFI", "${sources}")
+  env.produces("^/HOS.EFI", "^/HOS.EFI.map")
+  env.CheckThreadLocal(:hos_map_check, "^/HOS.EFI.map")
+  env["SIZE"] = "x86_64-w64-mingw32-size"
+  env.Size("^/HOS.size", "^/HOS.EFI")
+  env.Disassemble("^/HOS.txt", "^/HOS.EFI")
+  env.Image("^/HOS.img", "^/HOS.EFI")
 end
 
 task "run", desc: "Run HOS in QEMU" do
-  img = kernel_env.expand("^/hos.img")
-  sh %W[qemu-system-x86_64 -hda #{img}]
+  FileUtils.rm_rf("qemu")
+  FileUtils.mkdir_p("qemu")
+  img = hello_env.expand("^/HOS.img")
+  FileUtils.cp(img, "qemu")
+  ovmf = "OVMF.fd"
+  if File.exist?("/usr/share/edk2/x64/OVMF.fd")
+    ovmf = "/usr/share/edk2/x64/OVMF.fd"
+  end
+  sh %W[
+    qemu-system-x86_64
+    -machine q35
+    -cpu max
+    -serial file:qemu/serial.out
+    -bios #{ovmf}
+    -drive file=qemu/HOS.img,format=raw
+    -device qemu-xhci
+    -device usb-tablet]
 end
 
-task "run-efi", desc: "Run HOS EFI in QEMU" do
-  img = kernel_env.expand("^/hos-efi.img")
-  sh %W[qemu-system-x86_64 -bios OVMF.fd -hda #{img}]
+# See README.md for how to set up VirtualBox for HOS.
+task "mk-vmdk", desc: "Create VirtualBox VMDK virtual drive for HOS" do
+  path = File.expand_path(hello_env.expand("^/HOS.img"))
+  sectors = File.stat(path).size / 512
+  File.binwrite("HOS.vmdk", <<EOF)
+# Disk DescriptorFile
+version=1
+CID=1d1c3615
+parentCID=ffffffff
+createType="fullDevice"
+
+# Extent description
+RW #{sectors} FLAT "#{path}" 0
+
+# The disk Data Base 
+#DDB
+
+ddb.virtualHWVersion = "4"
+ddb.adapterType="ide"
+ddb.geometry.cylinders="8"
+ddb.geometry.heads="16"
+ddb.geometry.sectors="63"
+ddb.uuid.image="03783b5a-7587-4d8b-ad04-9d70f70a94c2"
+ddb.uuid.parent="00000000-0000-0000-0000-000000000000"
+ddb.uuid.modification="00000000-0000-0000-0000-000000000000"
+ddb.uuid.parentmodification="00000000-0000-0000-0000-000000000000"
+ddb.geometry.biosCylinders="8"
+ddb.geometry.biosHeads="16"
+ddb.geometry.biosSectors="63"
+EOF
+  #sh %W[VBoxManage createmedium disk --filename=HOS.vmdk --variant=RawDisk --format=VMDK --property RawDrive=#{File.expand_path(hello_env.expand("^/HOS.img"))}]
+end
+
+# See README.md for how to set up VirtualBox for HOS.
+task "run-vb", desc: "Run HOS in VirtualBox" do
+  sh %W[VBoxManage startvm HOS]
 end

fontgen/fontgen.c

@@ -1,224 +0,0 @@
-#include <stdlib.h>
-#include <stdint.h>
-#include <ft2build.h>
-#include <stdio.h>
-#include FT_FREETYPE_H
-#include <string.h>
-#include <strings.h>
-#include <ctype.h>
-
-#define N_CHARS 128
-
-#define round_up_26_6(val) (((val) + 63) >> 6u)
-
-int max_advance;
-int max_top = -9999;
-int min_bottom = 9999;
-int line_height;
-int baseline_offset;
-
-typedef struct {
-    int width;
-    int height;
-    int top;
-    int left;
-    uint8_t * bitmap;
-} char_info_t;
-
-static char_info_t char_infos[N_CHARS];
-
-static void load_char(FT_Face face, int char_code)
-{
-    if (FT_Load_Char(face, char_code, FT_LOAD_RENDER) != 0)
-    {
-        return;
-    }
-    int advance = round_up_26_6(face->glyph->advance.x);
-    if (advance > max_advance)
-    {
-        max_advance = advance;
-    }
-    if ((face->glyph->bitmap.width == 0) ||
-            (face->glyph->bitmap.rows == 0))
-    {
-        return;
-    }
-    char_infos[char_code].width = face->glyph->bitmap.width;
-    char_infos[char_code].height = face->glyph->bitmap.rows;
-    char_infos[char_code].top = face->glyph->bitmap_top;
-    if (char_infos[char_code].top > max_top)
-    {
-        max_top = char_infos[char_code].top;
-    }
-    int bottom = char_infos[char_code].top - char_infos[char_code].height;
-    if (bottom < min_bottom)
-    {
-        min_bottom = bottom;
-    }
-    char_infos[char_code].left = face->glyph->bitmap_left;
-    char_infos[char_code].bitmap = malloc(char_infos[char_code].width * char_infos[char_code].height);
-    memcpy(char_infos[char_code].bitmap,
-            face->glyph->bitmap.buffer,
-            char_infos[char_code].width * char_infos[char_code].height);
-}
-
-static const char * bare_header_name(const char * h_file_name)
-{
-    const char * p = rindex(h_file_name, '/');
-    if (p == NULL)
-    {
-        p = h_file_name;
-    }
-    else
-    {
-        p++;
-    }
-    return p;
-}
-
-static char * include_guard_name(const char * h_file_name)
-{
-    const char * p = bare_header_name(h_file_name);
-    char * guard_name = malloc(strlen(p) + 1);
-    strcpy(guard_name, p);
-    char * m = guard_name;
-    while (*m != '\0')
-    {
-        if ('a' <= *m && *m <= 'z')
-        {
-            *m = toupper(*m);
-        }
-        else if (('0' <= *m && *m <= '9') || ('A' <= *m && *m <= 'Z'))
-        {
-            /* no change */
-        }
-        else
-        {
-            *m = '_';
-        }
-        m++;
-    }
-    return guard_name;
-}
-
-static void generate_bytes(FILE * file, const uint8_t * bytes, int count)
-{
-    for (int i = 0; i < count; i++)
-    {
-        if (i % 8 == 0)
-        {
-            fprintf(file, "    ");
-        }
-        fprintf(file, "0x%02xu,", bytes[i]);
-        if ((i + 1) % 8 == 0)
-        {
-            fprintf(file, "\n");
-        }
-        else if (i < (count - 1))
-        {
-            fprintf(file, " ");
-        }
-    }
-    if (count % 8 != 0)
-    {
-        fprintf(file, "\n");
-    }
-}
-
-static void generate(const char * c_file_name)
-{
-    char * h_file_name = malloc(strlen(c_file_name) + 1);
-    strcpy(h_file_name, c_file_name);
-    h_file_name[strlen(h_file_name) - 1] = 'h';
-    char * guard = include_guard_name(h_file_name);
-
-    FILE * h_file = fopen(h_file_name, "wb");
-    fprintf(h_file, "#ifndef %s\n", guard);
-    fprintf(h_file, "#define %s\n\n", guard);
-    fprintf(h_file, "#include <stdint.h>\n");
-    fprintf(h_file, "typedef struct {\n    int width;\n    int height;\n    int top;\n    int left;\n    const uint8_t * bitmap;\n} fontgen_char_info_t;\n");
-    fprintf(h_file, "typedef struct {\n    int line_height;\n    int advance;\n    int baseline_offset;\n    const fontgen_char_info_t ** char_infos;\n} fontgen_font_t;\n");
-    fprintf(h_file, "extern const fontgen_font_t kfont;\n");
-    fprintf(h_file, "#endif\n");
-    fclose(h_file);
-
-    FILE * c_file = fopen(c_file_name, "wb");
-    fprintf(c_file, "#include \"%s\"\n", bare_header_name(h_file_name));
-    fprintf(c_file, "#include <stddef.h>\n");
-    for (int i = 0; i < N_CHARS; i++)
-    {
-        if (char_infos[i].width > 0)
-        {
-            fprintf(c_file, "static const uint8_t char_bitmap_%d[] = {\n", i);
-            generate_bytes(c_file, char_infos[i].bitmap, char_infos[i].width * char_infos[i].height);
-            fprintf(c_file, "};\n");
-        }
-        fprintf(c_file, "static const fontgen_char_info_t char_%d = {\n", i);
-        fprintf(c_file, "    %d,\n", char_infos[i].width);
-        fprintf(c_file, "    %d,\n", char_infos[i].height);
-        fprintf(c_file, "    %d,\n", char_infos[i].top);
-        fprintf(c_file, "    %d,\n", char_infos[i].left);
-        if (char_infos[i].width > 0)
-        {
-            fprintf(c_file, "    char_bitmap_%d,\n", i);
-        }
-        else
-        {
-            fprintf(c_file, "    NULL,\n");
-        }
-        fprintf(c_file, "};\n\n");
-    }
-    fprintf(c_file, "const fontgen_char_info_t * char_infos[] = {\n");
-    for (int i = 0; i < N_CHARS; i++)
-    {
-        fprintf(c_file, "    &char_%d,\n", i);
-    }
-    fprintf(c_file, "};\n");
-    fprintf(c_file, "const fontgen_font_t kfont = {\n");
-    fprintf(c_file, "    %d,\n", line_height);
-    fprintf(c_file, "    %d,\n", max_advance);
-    fprintf(c_file, "    %d,\n", baseline_offset);
-    fprintf(c_file, "    char_infos,\n");
-    fprintf(c_file, "};\n");
-    fclose(c_file);
-}
-
-int main(int argc, char * argv[])
-{
-    /* Expect: font file, size, out file */
-    if (argc != 4)
-    {
-        fprintf(stderr, "Incorrect arguments\n");
-        return 1;
-    }
-    const char * font_file = argv[1];
-    int size = atoi(argv[2]);
-    const char * out_file = argv[3];
-
-    FT_Library ft_library;
-    if (FT_Init_FreeType(&ft_library) != 0)
-    {
-        fprintf(stderr, "Could not initialize freetype\n");
-        return 2;
-    }
-
-    FT_Face face;
-    if (FT_New_Face(ft_library, font_file, 0, &face) != 0)
-    {
-        fprintf(stderr, "Could not open %s\n", font_file);
-        return 3;
-    }
-
-    FT_Set_Pixel_Sizes(face, 0, size);
-
-    for (int i = 0; i < N_CHARS; i++)
-    {
-        load_char(face, i);
-    }
-    line_height = round_up_26_6(face->size->metrics.height);
-    baseline_offset = (line_height - (max_top - min_bottom)) / 2 - min_bottom;
-
-    generate(out_file);
-
-    return 0;
-}

rscons

@@ -24,8 +24,8 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
-script = File.join(File.dirname(__FILE__), ".rscons-3.0.0-077c0388ca4d1d902141299abcc4b8f6.rb")
-unless File.exists?(script)
+script = File.join(File.dirname(__FILE__), ".rscons-3.1.0-4892f95d56c30bbe9aa0c9964062ec5b.rb")
+unless File.exist?(script)
   if File.read(__FILE__, mode: "rb") =~ /^#==>(.*)/
     require "zlib"
     require "base64"
@@ -43,4 +43,4 @@ load script
 if __FILE__ == $0
   Rscons::Cli.new.run(ARGV)
 end
-#==>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 truncated
+#==>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 truncated

src/boot.S

@@ -1,18 +0,0 @@
-.global hos_start
-.type hos_start, @function
-hos_start:
-    /* Set stack pointer. */
-    mov $_stack_end, %esp
- 
-    /* Jump to C. */
-    push $0
-    push $0
-    push $0
-    push %ebx
-    call hos_main
- 
-    cli
-1:  hlt
-    jmp 1b
- 
-.size hos_start, . - hos_start

src/fb.c

@@ -1,116 +0,0 @@
-#include "fb.h"
-#include <stddef.h>
-#include "mem.h"
-
-static struct {
-    uint32_t * addr;
-    uint32_t width;
-    uint32_t height;
-    uint32_t pitch;
-} fb;
-
-static inline uint32_t build_pixel(uint8_t r, uint8_t g, uint8_t b)
-{
-    return (r << 16u) | (g << 8u) | b;
-}
-
-static inline void fb_set_pixel(int x, int y, uint8_t r, uint8_t g, uint8_t b)
-{
-    fb.addr[fb.pitch * y + x] = build_pixel(r, g, b);
-}
-
-void fb_clear(void)
-{
-    memset32(fb.addr, 0u, fb.pitch * fb.height);
-}
-
-void fb_init(uint32_t * addr, uint32_t width, uint32_t height, uint32_t pitch)
-{
-    fb.addr = addr;
-    fb.width = width;
-    fb.height = height;
-    fb.pitch = pitch / 4u;
-    fb_clear();
-}
-
-uint32_t * fb_addr(void)
-{
-    return fb.addr;
-}
-
-bool fb_ready(void)
-{
-    return fb.addr != NULL;
-}
-
-uint32_t fb_width(void)
-{
-    return fb.width;
-}
-
-uint32_t fb_height(void)
-{
-    return fb.height;
-}
-
-void fb_blend_alpha8(const uint8_t * bitmap, int width, int height, int pitch, int x, int y, uint8_t r, uint8_t g, uint8_t b)
-{
-    if (((x + width) <= 0) || (x >= (int)fb.width) || ((y + height) <= 0) || (y >= (int)fb.height))
-    {
-        return;
-    }
-    if (x < 0)
-    {
-        width += x;
-        bitmap += (-x);
-        x = 0;
-    }
-    if (y < 0)
-    {
-        height += y;
-        bitmap += ((-y) * pitch);
-        y = 0;
-    }
-    if ((x + width) > (int)fb.width)
-    {
-        width = (int)fb.width - x;
-    }
-    if ((y + height) > (int)fb.height)
-    {
-        height = (int)fb.height - y;
-    }
-    uint32_t * target = &fb.addr[fb.pitch * y + x];
-    for (int row = 0; row < height; row++)
-    {
-        for (int col = 0; col < width; col++)
-        {
-            uint32_t alpha = bitmap[col];
-            uint32_t current_pixel = target[col];
-            uint8_t cr = (current_pixel >> 16u) & 0xFFu;
-            uint8_t cg = (current_pixel >> 8u) & 0xFFu;
-            uint8_t cb = current_pixel & 0xFFu;
-            uint8_t pr = alpha * r / 255u;
-            uint8_t pg = alpha * g / 255u;
-            uint8_t pb = alpha * b / 255u;
-            uint32_t current_alpha = 255u - alpha;
-            uint32_t pixel = build_pixel(
-                    pr + current_alpha * cr / 255u,
-                    pg + current_alpha * cg / 255u,
-                    pb + current_alpha * cb / 255u);
-            target[col] = pixel;
-        }
-        bitmap += pitch;
-        target += fb.pitch;
-    }
-}
-
-void fb_fill(int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b)
-{
-    uint32_t * target = &fb.addr[fb.pitch * y + x];
-    uint32_t pixel = build_pixel(r, g, b);
-    for (int row = 0; row < height; row++)
-    {
-        memset32(target, pixel, width);
-        target += fb.pitch;
-    }
-}

src/fb.h

@@ -1,16 +0,0 @@
-#ifndef FB_H
-#define FB_H
-
-#include <stdint.h>
-#include <stdbool.h>
-
-void fb_init(uint32_t * addr, uint32_t width, uint32_t height, uint32_t pitch);
-bool fb_ready(void);
-uint32_t * fb_addr(void);
-uint32_t fb_width(void);
-uint32_t fb_height(void);
-void fb_blend_alpha8(const uint8_t * bitmap, int width, int height, int pitch, int x, int y, uint8_t r, uint8_t g, uint8_t b);
-void fb_fill(int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b);
-void fb_clear(void);
-
-#endif

src/fb_text.c

@@ -1,11 +0,0 @@
-#include "fb_text.h"
-#include "kfont.h"
-#include "fb.h"
-
-void fb_text_render_char(int c, int x, int y, uint8_t r, uint8_t g, uint8_t b)
-{
-    const fontgen_char_info_t * char_info = kfont.char_infos[c];
-    y += kfont.line_height - kfont.baseline_offset - char_info->top;
-    x += char_info->left;
-    fb_blend_alpha8(char_info->bitmap, char_info->width, char_info->height, char_info->width, x, y, r, g, b);
-}

src/fb_text.h

@@ -1,8 +0,0 @@
-#ifndef FB_TEXT_H
-#define FB_TEXT_H
-
-#include <stdint.h>
-
-void fb_text_render_char(int c, int x, int y, uint8_t r, uint8_t g, uint8_t b);
-
-#endif

src/fontgen/fontgen.c

@@ -0,0 +1,235 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <ft2build.h>
+#include <stdio.h>
+#include FT_FREETYPE_H
+#include <string.h>
+#include <strings.h>
+#include <ctype.h>
+
+#define N_CHARS 128
+
+#define round_up_26_6(val) (((val) + 63) >> 6u)
+
+int max_advance;
+int max_top = -9999;
+int min_bottom = 9999;
+int line_height;
+int baseline_offset;
+
+typedef struct {
+    int width;
+    int height;
+    int top;
+    int left;
+    uint8_t * bitmap;
+} char_info_t;
+
+static char_info_t char_infos[N_CHARS];
+
+static void load_char(FT_Face face, int char_code)
+{
+    if (FT_Load_Char(face, char_code, FT_LOAD_RENDER) != 0)
+    {
+        return;
+    }
+    int advance = round_up_26_6(face->glyph->advance.x);
+    if (advance > max_advance)
+    {
+        max_advance = advance;
+    }
+    if ((face->glyph->bitmap.width == 0) ||
+            (face->glyph->bitmap.rows == 0))
+    {
+        return;
+    }
+    char_infos[char_code].width = face->glyph->bitmap.width;
+    char_infos[char_code].height = face->glyph->bitmap.rows;
+    char_infos[char_code].top = face->glyph->bitmap_top;
+    if (char_infos[char_code].top > max_top)
+    {
+        max_top = char_infos[char_code].top;
+    }
+    int bottom = char_infos[char_code].top - char_infos[char_code].height;
+    if (bottom < min_bottom)
+    {
+        min_bottom = bottom;
+    }
+    char_infos[char_code].left = face->glyph->bitmap_left;
+    char_infos[char_code].bitmap = malloc(char_infos[char_code].width * char_infos[char_code].height);
+    memcpy(char_infos[char_code].bitmap,
+            face->glyph->bitmap.buffer,
+            char_infos[char_code].width * char_infos[char_code].height);
+}
+
+static void generate_bytes(FILE * file, const uint8_t * bytes, int count)
+{
+    for (int i = 0; i < count; i++)
+    {
+        if (i % 8 == 0)
+        {
+            fprintf(file, "                ");
+        }
+        fprintf(file, "0x%02xu,", bytes[i]);
+        if ((i + 1) % 8 == 0)
+        {
+            fprintf(file, "\n");
+        }
+        else if (i < (count - 1))
+        {
+            fprintf(file, " ");
+        }
+    }
+    if (count % 8 != 0)
+    {
+        fprintf(file, "\n");
+    }
+}
+
+static bool generate(const char * d_file_name)
+{
+    FILE * fh = fopen(d_file_name, "wb");
+    fprintf(fh, "module hulk.kfont;\n");
+    fprintf(fh, "struct CharInfo {\n");
+    fprintf(fh, "    /** Glyph bitmap width. */\n");
+    fprintf(fh, "    ubyte width;\n");
+    fprintf(fh, "    /** Glyph bitmap height. */\n");
+    fprintf(fh, "    ubyte height;\n");
+    fprintf(fh, "    /** Glyph bitmap top offset (descent from top of text row). */\n");
+    fprintf(fh, "    ubyte top;\n");
+    fprintf(fh, "    /** Glyph bitmap left offset. */\n");
+    fprintf(fh, "    ubyte left;\n");
+    fprintf(fh, "    /** Glyph bitmap. */\n");
+    fprintf(fh, "    const ubyte[] bitmap;\n");
+    fprintf(fh, "};\n");
+    fprintf(fh, "struct FontInfo {\n");
+    fprintf(fh, "    /** Font line height. */\n");
+    fprintf(fh, "    ubyte line_height;\n");
+    fprintf(fh, "    /** Font advance. */\n");
+    fprintf(fh, "    ubyte advance;\n");
+    fprintf(fh, "    /** Characters. */\n");
+    fprintf(fh, "    const CharInfo[] chars;\n");
+    fprintf(fh, "};\n");
+    fprintf(fh, "/** Kernel font data. */\n");
+    fprintf(fh, "__gshared const FontInfo Kfont = {\n");
+    fprintf(fh, "    %du,\n", line_height);
+    fprintf(fh, "    %du,\n", max_advance);
+    fprintf(fh, "    [\n");
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        fprintf(fh, "        /* %d */", i);
+        fprintf(fh, "        CharInfo(\n");
+        fprintf(fh, "            %du /* width */,\n", char_infos[i].width);
+        fprintf(fh, "            %du /* height */,\n", char_infos[i].height);
+        fprintf(fh, "            %du /* top */,\n", char_infos[i].top);
+        fprintf(fh, "            %du /* left */,\n", char_infos[i].left);
+        if (char_infos[i].width > 0)
+        {
+            fprintf(fh, "            [\n");
+            generate_bytes(fh, char_infos[i].bitmap, char_infos[i].width * char_infos[i].height);
+            fprintf(fh, "            ]\n");
+        }
+        else
+        {
+            fprintf(fh, "            []\n");
+        }
+        fprintf(fh, "        ),\n");
+    }
+    fprintf(fh, "    ],\n");
+    fprintf(fh, "};\n");
+    fclose(fh);
+    return true;
+}
+
+int main(int argc, char * argv[])
+{
+    /* Expect: font file, size, out file */
+    if (argc != 4)
+    {
+        fprintf(stderr, "Incorrect arguments\n");
+        return 1;
+    }
+    const char * font_file = argv[1];
+    int size = atoi(argv[2]);
+    const char * out_file = argv[3];
+
+    FT_Library ft_library;
+    if (FT_Init_FreeType(&ft_library) != 0)
+    {
+        fprintf(stderr, "Could not initialize freetype\n");
+        return 2;
+    }
+
+    FT_Face face;
+    if (FT_New_Face(ft_library, font_file, 0, &face) != 0)
+    {
+        fprintf(stderr, "Could not open %s\n", font_file);
+        return 3;
+    }
+
+    FT_Set_Pixel_Sizes(face, 0, size);
+
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        load_char(face, i);
+    }
+    line_height = round_up_26_6(face->size->metrics.height);
+    baseline_offset = (line_height - (max_top - min_bottom)) / 2 - min_bottom;
+
+    if ((line_height < 1) || (line_height > 0xFF))
+    {
+        fprintf(stderr, "Error: invalid line_height %d\n", line_height);
+        return false;
+    }
+    if ((max_advance < 1) || (max_advance > 0xFF))
+    {
+        fprintf(stderr, "Error: invalid max_advance %d\n", max_advance);
+        return false;
+    }
+
+    for (int i = 0; i < N_CHARS; i++)
+    {
+        if ((char_infos[i].width < 0) || (char_infos[i].width > max_advance))
+        {
+            fprintf(stderr, "Error: invalid character %d width: %d\n", i, char_infos[i].width);
+            return false;
+        }
+        if ((char_infos[i].height < 0) || (char_infos[i].height > line_height))
+        {
+            fprintf(stderr, "Error: invalid character %d height: %d\n", i, char_infos[i].height);
+            return false;
+        }
+        if ((char_infos[i].left < 0) || (char_infos[i].left >= max_advance))
+        {
+            fprintf(stderr, "Error: invalid character %d left: %d\n", i, char_infos[i].left);
+            return false;
+        }
+        /* Adjust character top to be index downward from top of font box. */
+        char_infos[i].top = line_height - baseline_offset - char_infos[i].top;
+        if ((char_infos[i].top < 0) || (char_infos[i].top >= line_height))
+        {
+            fprintf(stderr, "Error: invalid character %d top: %d\n", i, char_infos[i].top);
+            return false;
+        }
+        if ((char_infos[i].left + char_infos[i].width) > max_advance)
+        {
+            fprintf(stderr, "Error: character %d left (%d) + width (%d) > advance (%d)\n",
+                    i, char_infos[i].left, char_infos[i].width, max_advance);
+            return false;
+        }
+        if ((char_infos[i].top + char_infos[i].height) > line_height)
+        {
+            fprintf(stderr, "Error: character %d top (%d) + height (%d) > line height (%d)\n",
+                    i, char_infos[i].top, char_infos[i].height, line_height);
+            return false;
+        }
+    }
+
+    if (!generate(out_file))
+    {
+        return 1;
+    }
+
+    return 0;
+}

src/gdt.S

@@ -1,16 +0,0 @@
-.global gdt_set
-.extern gdtr
-.type gdt_set, @function
-gdt_set:
-    lgdt gdtr
-    jmp $0x8, $gdt_set_reload
-gdt_set_reload:
-    mov $0x10, %ax
-    mov %ax, %ds
-    mov %ax, %es
-    mov %ax, %fs
-    mov %ax, %gs
-    mov %ax, %ss
-    ret
-
-.size gdt_set, . - gdt_set

src/gdt.c

@@ -1,20 +0,0 @@
-#include "gdt.h"
-
-static const gdt_entry_t gdt_entries[] = {
-    /* Null descriptor */
-    0u,
-    /* Code segment for kernel */
-    gdt_build_entry(0u, 0xFFFFFu, 1u, 0u, 1u, 1u, 0u, 1u, 0u, 1u, 1u, 0u),
-    /* Data segment for kernel */
-    gdt_build_entry(0u, 0xFFFFFu, 1u, 0u, 1u, 0u, 0u, 1u, 0u, 1u, 1u, 0u),
-};
-
-gdtr_t gdtr;
-
-void gdt_init(void)
-{
-    gdtr.size = sizeof(gdt_entries);
-    gdtr.offset_lower = (uintptr_t)gdt_entries & 0xFFFFu;
-    gdtr.offset_upper = (uintptr_t)gdt_entries >> 16u;
-    gdt_set();
-}

src/gdt.h

@@ -1,34 +0,0 @@
-#ifndef GDT_H
-#define GDT_H
-
-#include <stdint.h>
-
-typedef struct {
-    uint16_t size;
-    uint16_t offset_lower;
-    uint16_t offset_upper;
-    uint16_t _reserved;
-} gdtr_t;
-
-typedef uint64_t gdt_entry_t;
-#define gdt_build_entry(base, limit, pr, privl, s, ex, dc, rw, ac, gr, sz, l) \
-    (gdt_entry_t)( \
-            (((gdt_entry_t)base << 32) & 0xFF00000000000000ull) | /* Base 0:15 */ \
-            (((gdt_entry_t)gr & 0x1u) << 55) | /* Granularity (0 = bytes, 1 = blocks) */ \
-            (((gdt_entry_t)sz & 0x1u) << 54) | /* Size (0 = 16-bit, 1 = 32-bit) */ \
-            (((gdt_entry_t)l & 0x1u) << 53) | /* L flag (x86_64 code) */ \
-            (((gdt_entry_t)limit << 32) & 0x000F000000000000ull) | /* Limit 16:19 */ \
-            (((gdt_entry_t)pr & 0x1u) << 47) | /* Present flag */ \
-            (((gdt_entry_t)privl & 0x3u) << 45) | /* Privilege (ring level) */ \
-            (((gdt_entry_t)s & 0x1u) << 44) | /* Type (0 = system, 1 = code/data) */ \
-            (((gdt_entry_t)ex & 0x1u) << 43) | /* Executable flag */ \
-            (((gdt_entry_t)dc & 0x1u) << 42) | /* Direction/Conforming */ \
-            (((gdt_entry_t)rw & 0x1u) << 41) | /* Readable/Writable */ \
-            (((gdt_entry_t)ac & 0x1u) << 40) | /* Accessed flag */ \
-            (((gdt_entry_t)base << 16) & 0x000000FFFFFF0000ull) | /* Base 0:23 */ \
-             ((gdt_entry_t)limit & 0x000000000000FFFFull)) /* Limit 0:15 */
-
-void gdt_init(void);
-void gdt_set(void);
-
-#endif

src/hello/console.d

@@ -0,0 +1,88 @@
+/**
+ * HELLO console support.
+ */
+module hello.console;
+
+import uefi;
+import hello.hello;
+import core.stdc.stdarg;
+import hulk.writef;
+
+struct Console
+{
+    /**
+     * Write a character to the console.
+     *
+     * @param ch Character to write.
+     */
+    public static void write(ubyte ch)
+    {
+        if (ch == '\n')
+        {
+            write('\r');
+        }
+        CHAR16[2] s16 = [ch, 0];
+        st.ConOut.OutputString(st.ConOut, &s16[0]);
+    }
+
+    /**
+     * Write a formatted string to the console.
+     *
+     * @param s Format string.
+     * @param args Variable arguments structure.
+     */
+    public static void writef(string s, va_list args)
+    {
+        hulk.writef.writef(s, args, function void(ubyte ch) {
+                    Console.write(ch);
+                });
+    }
+
+    /**
+     * Write a formatted string to the console.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writef(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        va_end(args);
+    }
+
+    /**
+     * Write a formatted string and newline to the console.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writefln(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        writef("\n", args);
+        va_end(args);
+    }
+
+    /**
+     * Write a message to press any key and wait for a key to be pressed.
+     */
+    public static void wait_key()
+    {
+        writefln("Press any key...");
+        st.ConIn.Reset(st.ConIn, FALSE);
+        EFI_INPUT_KEY key;
+        while (st.ConIn.ReadKeyStroke(st.ConIn, &key) == EFI_NOT_READY)
+        {
+        }
+    }
+
+    /**
+     * Clear the console.
+     */
+    public static void clear()
+    {
+        st.ConOut.ClearScreen(st.ConOut);
+    }
+}

src/hello/hello.d

@@ -0,0 +1,577 @@
+/**
+ * HELLO, the HOS EFI Lightweight LOader.
+ */
+module hello.hello;
+
+import uefi;
+import hello.console;
+import hulk.bootinfo;
+import hulk.header;
+import hulk.pagetable;
+import hulk.cpu;
+import hulk.memory;
+import ldc.llvmasm;
+import hulk.serial;
+
+__gshared EFI_SYSTEM_TABLE * st;
+/** HULK binary start address, 4KB-aligned. */
+extern extern(C) __gshared ubyte _hulk_bin_start;
+/** HULK binary end address, 4KB-aligned. */
+extern extern(C) __gshared ubyte _hulk_bin_end;
+private align(4096) __gshared ubyte[1024 * 1024] scratch_buffer;
+/** Index to the memory map region being used to allocate page tables. */
+private __gshared size_t memory_map_page_table_alloc_index;
+
+private HulkHeader * hulk_header()
+{
+    return cast(HulkHeader *)&_hulk_bin_start;
+}
+
+private BootInfo * bootinfo()
+{
+    return &hulk_header().bootinfo;
+}
+
+private ulong hulk_bin_phys()
+{
+    return cast(ulong)&_hulk_bin_start;
+}
+
+private ulong hulk_bin_size()
+{
+    return cast(ulong)&_hulk_bin_end - cast(ulong)&_hulk_bin_start;
+}
+
+private ulong hulk_bss_size()
+{
+    return cast(ulong)hulk_header().hulk_bss_size;
+}
+
+private ulong hulk_stack_size()
+{
+    return hulk_header().stack_size;
+}
+
+private ulong hulk_virt_base_address()
+{
+    return hulk_header().virt_base;
+}
+
+private ulong hulk_virt_stack_top()
+{
+    return hulk_header().virt_stack_top;
+}
+
+private ulong hulk_virt_framebuffer_address()
+{
+    return hulk_header().virt_fb_buffer;
+}
+
+/**
+ * Detect if we're running in QEMU.
+ */
+private bool in_qemu()
+{
+    ulong * firmware_vendor = cast(ulong *) st.FirmwareVendor;
+    ulong fv1 = firmware_vendor[0];
+    return fv1 ==
+        ((cast(ulong)'E') |
+         (cast(ulong)'D' << 16) |
+         (cast(ulong)'K' << 32) |
+         (cast(ulong)' ' << 48));
+}
+
+/**
+ * Set a graphics mode.
+ */
+private bool set_graphics_mode()
+{
+    uint max_horizontal_resolution = in_qemu() ? 1920u : 0xFFFFFFFFu;
+    UINTN buffer_size = scratch_buffer.sizeof;
+    EFI_GUID gop_guid = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
+    EFI_HANDLE * handles = cast(EFI_HANDLE *)&scratch_buffer[0];
+    EFI_STATUS status = st.BootServices.LocateHandle(ByProtocol,
+            &gop_guid, null, &buffer_size, handles);
+    if (status != EFI_SUCCESS)
+    {
+        Console.writefln("LocateHandle: error %x", status);
+        return false;
+    }
+    EFI_HANDLE gop_handle = handles[0];
+    EFI_HANDLE gop_interface;
+    status = st.BootServices.HandleProtocol(gop_handle,
+            &gop_guid, &gop_interface);
+    if (status != EFI_SUCCESS)
+    {
+        Console.writefln("HandleProtocol: error %x", status);
+        return false;
+    }
+    if (gop_interface == null)
+    {
+        Console.writefln("null interface from HandleProtocol");
+        return false;
+    }
+    EFI_GRAPHICS_OUTPUT_PROTOCOL * gop = cast(EFI_GRAPHICS_OUTPUT_PROTOCOL *)gop_interface;
+    UINTN info_size;
+    EFI_GRAPHICS_OUTPUT_MODE_INFORMATION * info;
+    uint best_width;
+    uint best_mode_number;
+    for (uint mode_number = 0u;
+         (status = gop.QueryMode(gop, mode_number, &info_size, &info)) == EFI_SUCCESS;
+         mode_number++)
+    {
+        if ((info.HorizontalResolution > best_width) &&
+            (info.HorizontalResolution <= max_horizontal_resolution))
+        {
+            best_width = info.HorizontalResolution;
+            best_mode_number = mode_number;
+        }
+        st.BootServices.FreePool(info);
+    }
+    if ((status = gop.SetMode(gop, best_mode_number)) != EFI_SUCCESS)
+    {
+        Console.writefln("SetMode: Error %x\n", status);
+        return false;
+    }
+    bootinfo().fb.buffer = cast(uint *)gop.Mode.FrameBufferBase;
+    bootinfo().fb.width = gop.Mode.Info.HorizontalResolution;
+    bootinfo().fb.height = gop.Mode.Info.VerticalResolution;
+    bootinfo().fb.stride = gop.Mode.Info.PixelsPerScanLine;
+    bootinfo().fb.format = gop.Mode.Info.PixelFormat;
+    return true;
+}
+
+/**
+ * Walk the EFI memory map and translate it to the HULK bootinfo format.
+ */
+private void get_memory_map(ulong * physical_address_limit, UINTN * memory_map_key)
+{
+    immutable static ubyte[] efi_to_hulk_memory_map_type = [
+        BootInfo.MemoryRegion.Type.Reserved, // EfiReservedMemoryType
+        BootInfo.MemoryRegion.Type.Bootloader, // EfiLoaderCode
+        BootInfo.MemoryRegion.Type.Bootloader, // EfiLoaderData
+        BootInfo.MemoryRegion.Type.Bootloader, // EfiBootServicesCode
+        BootInfo.MemoryRegion.Type.Bootloader, // EfiBootServicesData
+        BootInfo.MemoryRegion.Type.Reserved, // EfiRuntimeServicesCode
+        BootInfo.MemoryRegion.Type.Reserved, // EfiRuntimeServicesData
+        BootInfo.MemoryRegion.Type.Conventional, // EfiConventionalMemory
+        BootInfo.MemoryRegion.Type.Unusable, // EfiUnusableMemory
+        BootInfo.MemoryRegion.Type.ACPIReclaim, // EfiACPIReclaimMemory
+        BootInfo.MemoryRegion.Type.ACPINVS, // EfiACPIMemoryNVS
+        BootInfo.MemoryRegion.Type.MemoryMappedIO, // EfiMemoryMappedIO
+        BootInfo.MemoryRegion.Type.MemoryMappedIOPortSpace, // EfiMemoryMappedIOPortSpace
+        BootInfo.MemoryRegion.Type.PalCode, // EfiPalCode
+    ];
+    *physical_address_limit = 0u;
+    UINTN memory_map_size = scratch_buffer.sizeof;
+    UINTN descriptor_size;
+    UINT32 descriptor_version;
+    ubyte * scratch_base = cast(ubyte *)&scratch_buffer[0];
+    UINTN status = st.BootServices.GetMemoryMap(
+            &memory_map_size,
+            cast(EFI_MEMORY_DESCRIPTOR *)scratch_base,
+            memory_map_key,
+            &descriptor_size,
+            &descriptor_version);
+    if (status != EFI_SUCCESS)
+    {
+        Console.writefln("GetMemoryMap: Error %x", status);
+        for (;;) {}
+    }
+    size_t n_entries = memory_map_size / descriptor_size;
+    size_t count;
+    bool found_bss;
+    bool found_stack;
+    bool found_fb_buffer1;
+    const(size_t) fb_size = (bootinfo().fb.stride * bootinfo().fb.height * 4u + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
+    for (count = 0u; count < n_entries; count++)
+    {
+        if (count > bootinfo().memory_map.length)
+        {
+            Console.writefln("Memory map too large");
+            for (;;) {}
+        }
+        EFI_MEMORY_DESCRIPTOR * descriptor = cast(EFI_MEMORY_DESCRIPTOR *)&scratch_base[count * descriptor_size];
+        ulong end_address = descriptor.PhysicalStart + descriptor.NumberOfPages * 4096u;
+        if ((end_address > *physical_address_limit) &&
+            ((descriptor.Type == EfiLoaderCode) ||
+             (descriptor.Type == EfiLoaderData) ||
+             (descriptor.Type == EfiBootServicesCode) ||
+             (descriptor.Type == EfiBootServicesData) ||
+             (descriptor.Type == EfiRuntimeServicesCode) ||
+             (descriptor.Type == EfiRuntimeServicesData) ||
+             (descriptor.Type == EfiConventionalMemory)))
+        {
+            *physical_address_limit = end_address;
+        }
+        if (descriptor.Type >= efi_to_hulk_memory_map_type.length)
+        {
+            Serial.writefln("Unexpected descriptor type %u", descriptor.Type);
+            continue;
+        }
+        bootinfo().memory_map[count].base = descriptor.PhysicalStart;
+        bootinfo().memory_map[count].size = descriptor.NumberOfPages * 4096u;
+        bootinfo().memory_map[count].type = efi_to_hulk_memory_map_type[descriptor.Type];
+        if ((!found_bss) &&
+            (descriptor.Type == EfiConventionalMemory) &&
+            (bootinfo().memory_map[count].size >= hulk_bss_size()))
+        {
+            bootinfo().bss_phys = bootinfo().memory_map[count].base;
+            bootinfo().memory_map[count].base += hulk_bss_size();
+            bootinfo().memory_map[count].size -= hulk_bss_size();
+            Serial.writefln("Locating HULK BSS at %x:%x",
+                    bootinfo().bss_phys,
+                    bootinfo().bss_phys + hulk_bss_size() - 1u);
+            found_bss = true;
+        }
+        if ((!found_stack) &&
+            (descriptor.Type == EfiConventionalMemory) &&
+            (bootinfo().memory_map[count].size >= hulk_stack_size()))
+        {
+            bootinfo().stack_phys = bootinfo().memory_map[count].base;
+            bootinfo().memory_map[count].base += hulk_stack_size();
+            bootinfo().memory_map[count].size -= hulk_stack_size();
+            Serial.writefln("Locating HULK stack at %x:%x",
+                    bootinfo().stack_phys,
+                    bootinfo().stack_phys + hulk_stack_size() - 1u);
+            found_stack = true;
+        }
+        if ((!found_fb_buffer1) &&
+            (descriptor.Type == EfiConventionalMemory) &&
+            (bootinfo().memory_map[count].size >= fb_size))
+        {
+            bootinfo().fb_buffer1_phys = bootinfo().memory_map[count].base;
+            bootinfo().memory_map[count].base += fb_size;
+            bootinfo().memory_map[count].size -= fb_size;
+            Serial.writefln("Locating HULK FB1 at %x:%x",
+                    bootinfo().fb_buffer1_phys,
+                    bootinfo().fb_buffer1_phys + fb_size - 1u);
+            found_fb_buffer1 = true;
+        }
+        Serial.writefln("Memory range %x:%x (%u)",
+                bootinfo().memory_map[count].base,
+                bootinfo().memory_map[count].base + bootinfo().memory_map[count].size - 1u,
+                bootinfo().memory_map[count].type);
+    }
+    bootinfo().memory_map_count = count;
+    if ((!found_bss) || (!found_stack) || (!found_fb_buffer1))
+    {
+        for (;;) {}
+    }
+}
+
+private void * alloc_pt_page()
+{
+    BootInfo.MemoryRegion * regions = &bootinfo().memory_map[0];
+    for (;;)
+    {
+        BootInfo.MemoryRegion * region = &bootinfo().memory_map[memory_map_page_table_alloc_index];
+        if ((region.type == BootInfo.MemoryRegion.Type.Conventional) && (region.size >= PAGE_SIZE))
+        {
+            void * addr = cast(void *)region.base;
+            region.base += PAGE_SIZE;
+            region.size -= PAGE_SIZE;
+            return addr;
+        }
+        memory_map_page_table_alloc_index++;
+        if (memory_map_page_table_alloc_index >= bootinfo().memory_map_count)
+        {
+            return null;
+        }
+    }
+}
+
+/**
+ * Allocate a new page table.
+ */
+private PageTable * new_page_table()
+{
+    PageTable * pt = cast(PageTable *)alloc_pt_page();
+    if (pt == null)
+    {
+        return null;
+    }
+    memset64(pt, 0u, 512);
+    return pt;
+}
+
+/**
+ * Map a virtual address to a physical address using 4KB pages.
+ *
+ * @param source_page Source page address.
+ * @param dest_page Destination page address.
+ * @param pt_base Page table base address.
+ */
+private bool map4k(ulong source_page, ulong dest_page, PageTable * pt_base)
+{
+    PageTable * pt = pt_base;
+    for (size_t level = 0; level < 4u; level++)
+    {
+        PageTableEntry * ppte = pt.entry(source_page, level);
+        PageTableEntry pte = *ppte;
+        if (pte.present)
+        {
+            pt = pte.follow();
+        }
+        else
+        {
+            PageTable * next_pt;
+            ulong addr;
+            if (level < 3u)
+            {
+                next_pt = new_page_table();
+                if (next_pt == null)
+                {
+                    return false;
+                }
+                addr = cast(ulong)next_pt;
+            }
+            else
+            {
+                addr = dest_page;
+            }
+            *ppte = PageTableEntry(addr, PT_WRITABLE | PT_PRESENT);
+            pt = next_pt;
+        }
+    }
+    return true;
+}
+
+/**
+ * Map a virtual region to a physical region using 4KB pages.
+ *
+ * @param source Source address.
+ * @param dest Destination address.
+ * @param size Region size.
+ * @param pt_base Page table base address.
+ */
+private bool map4kregion(ulong source, ulong dest, size_t size, PageTable * pt_base)
+{
+    ulong end = source + size;
+    while (source < end)
+    {
+        if (!map4k(source, dest, pt_base))
+        {
+            return false;
+        }
+        source += 4096u;
+        dest += 4096u;
+    }
+    return true;
+}
+
+/**
+ * Map a virtual address to a physical address using 2MB pages.
+ *
+ * @param source_page Source page address.
+ * @param dest_page Destination page address.
+ * @param pt_base Page table base address.
+ */
+private bool map2m(ulong source_page, ulong dest_page, PageTable * pt_base)
+{
+    PageTable * pt = pt_base;
+    for (size_t level = 0; level < 3u; level++)
+    {
+        PageTableEntry * ppte = pt.entry(source_page, level);
+        PageTableEntry pte = *ppte;
+        if (pte.present)
+        {
+            pt = pte.follow();
+        }
+        else
+        {
+            PageTable * next_pt;
+            if (level < 2u)
+            {
+                next_pt = new_page_table();
+                if (next_pt == null)
+                {
+                    return false;
+                }
+                *ppte = PageTableEntry(next_pt, PT_WRITABLE | PT_PRESENT);
+            }
+            else
+            {
+                *ppte = PageTableEntry(dest_page, PT_HUGE_PAGE | PT_WRITABLE | PT_PRESENT);
+            }
+            pt = next_pt;
+        }
+    }
+    return true;
+}
+
+/**
+ * Map HULK virtual addresses to physical kernel location.
+ *
+ * @param pt_base Page table base address.
+ */
+private bool map_hulk(PageTable * pt_base)
+{
+    /* Map HULK bin region. */
+    ulong virt = hulk_virt_base_address();
+    if (!map4kregion(virt, hulk_bin_phys(), hulk_bin_size(), pt_base))
+    {
+        return false;
+    }
+    /* Map HULK bss region. */
+    virt += hulk_bin_size();
+    if (!map4kregion(virt, bootinfo().bss_phys, hulk_bss_size(), pt_base))
+    {
+        return false;
+    }
+    /* Map HULK stack. */
+    virt = hulk_virt_stack_top() - hulk_stack_size();
+    if (!map4kregion(virt, bootinfo().stack_phys, hulk_stack_size(), pt_base))
+    {
+        return false;
+    }
+    return true;
+}
+
+/**
+ * Build page tables in preparation to jump to HULK.
+ *
+ * @param physical_address_limit Maximum physical address to identity map.
+ */
+private bool build_page_tables(ulong physical_address_limit)
+{
+    PageTable * pt_base = new_page_table();
+    if (pt_base == null)
+    {
+        return false;
+    }
+    /* Map physical RAM. */
+    for (size_t addr = 0u; addr < physical_address_limit; addr += (2u * 1024u * 1024u))
+    {
+        if (!map2m(addr, addr, pt_base))
+        {
+            return false;
+        }
+    }
+    /* Map any memory regions that are outside physical RAM. */
+    for (size_t i = 0u; i < bootinfo().memory_map_count; i++)
+    {
+        ulong addr = bootinfo().memory_map[i].base;
+        if (addr >= physical_address_limit)
+        {
+            if (!map4kregion(addr, addr, bootinfo().memory_map[i].size, pt_base))
+            {
+                return false;
+            }
+        }
+    }
+    /* Map graphics framebuffer. */
+    ulong framebuffer_size = bootinfo().fb.height * bootinfo().fb.stride * 4u;
+    ulong fb_phys = cast(ulong)bootinfo().fb.buffer;
+    ulong fb_virt = hulk_virt_framebuffer_address();
+    if (!map4kregion(fb_virt, fb_phys, framebuffer_size, pt_base))
+    {
+        return false;
+    }
+    /* Map HULK regions. */
+    if (!map_hulk(pt_base))
+    {
+        return false;
+    }
+    /* Switch to the new page table. */
+    write_cr3(cast(ulong)pt_base);
+    return true;
+}
+
+/**
+ * Jump to HULK entry point.
+ */
+private void jump_to_hulk()
+{
+    __asm(
+            "jmpq *$0",
+            "r,{rsp}",
+            hulk_header().entry, hulk_virt_stack_top());
+}
+
+/**
+ * Find the ACPI XSDT.
+ *
+ * @return Whether it was found.
+ */
+private bool find_acpi_xsdt()
+{
+    for (size_t i = 0u; i < st.NumberOfTableEntries; i++)
+    {
+        if ((st.ConfigurationTable[i].VendorGuid == EFI_ACPI_TABLE_GUID) ||
+            (st.ConfigurationTable[i].VendorGuid == ACPI_TABLE_GUID))
+        {
+            enum ulong rsdp_magic = 0x20525450_20445352u;
+            const(EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER) * rdsp = cast(const(EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER) *)st.ConfigurationTable[i].VendorTable;
+            if (rdsp.Signature == rsdp_magic)
+            {
+                if (rdsp.Revision >= EFI_ACPI_2_0_ROOT_SYSTEM_DESCRIPTION_POINTER_REVISION)
+                {
+                    bootinfo().acpi_xsdt_phys = rdsp.XsdtAddress;
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * EFI application entry point.
+ *
+ * @param image_handle EFI application handle.
+ * @param st Pointer to EFI system table.
+ */
+extern (C) EFI_STATUS efi_main(EFI_HANDLE image_handle, EFI_SYSTEM_TABLE * st)
+{
+    .st = st;
+
+    Console.clear();
+
+    Console.writefln("Welcome to HELLO, HOS EFI Lightweight LOader, v0.1.0");
+    Console.writefln("Firmware vendor: '%S', version: 0x%x", st.FirmwareVendor, st.FirmwareVendor);
+
+    if (!find_acpi_xsdt())
+    {
+        Console.writefln("Error: Could not locate ACPI XSDT");
+        Console.wait_key();
+        return EFI_SUCCESS;
+    }
+
+    if (!set_graphics_mode())
+    {
+        Console.wait_key();
+        return EFI_SUCCESS;
+    }
+
+    ulong physical_address_limit;
+    UINTN memory_map_key;
+    for (;;)
+    {
+        get_memory_map(&physical_address_limit, &memory_map_key);
+
+        EFI_STATUS status = st.BootServices.ExitBootServices(image_handle, memory_map_key);
+        if (status == EFI_INVALID_PARAMETER)
+        {
+            continue;
+        }
+        if (status == EFI_SUCCESS)
+        {
+            break;
+        }
+        Console.writefln("ExitBootServices: Error %x", status);
+        Console.wait_key();
+        return EFI_SUCCESS;
+    }
+
+    if (!build_page_tables(physical_address_limit))
+    {
+        return EFI_SUCCESS;
+    }
+
+    bootinfo().hulk_phys = hulk_bin_phys();
+
+    jump_to_hulk();
+
+    return EFI_SUCCESS;
+}

src/hos_main.c

@@ -1,25 +0,0 @@
-#include <stdint.h>
-#include "fb.h"
-#include "mbinfo.h"
-#include "klog.h"
-#include "gdt.h"
-#include "mm.h"
-
-void hos_main(uint32_t mbinfo_addr)
-{
-    gdt_init();
-    if (!mbinfo_init(mbinfo_addr))
-    {
-        return;
-    }
-    if (!fb_ready())
-    {
-        return;
-    }
-    klog_init();
-    klog_printf("Welcome to HOS!\n");
-    mm_init();
-    mbinfo_load();
-    klog_printf("Found %dKB of usable RAM\n", mm_get_total_ram() / 1024u);
-    klog_printf("Kernel is %dKB at 0x%x\n", mm_get_kernel_size() / 1024u, mm_get_kernel_address());
-}

src/hos_printf.c

@@ -1,281 +0,0 @@
-#include "hos_printf.h"
-#include <stdint.h>
-#include <stdbool.h>
-#include "string.h"
-
-static size_t format_dec(char * buffer, int32_t v)
-{
-    size_t sz = 0u;
-    bool printing = false;
-    if (v < 0)
-    {
-        buffer[sz++] = '-';
-        v = -v;
-    }
-    for (int32_t div = 1000000000; div >= 1; div /= 10)
-    {
-        int32_t digit = v / div;
-        v %= div;
-        if ((digit != 0) || (div == 1))
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            buffer[sz++] = digit + '0';
-        }
-    }
-    return sz;
-}
-
-static size_t format_dec64(char * buffer, int64_t v)
-{
-    size_t sz = 0u;
-    bool printing = false;
-    if (v < 0)
-    {
-        buffer[sz++] = '-';
-        v = -v;
-    }
-    for (int64_t div = 1000000000000000000; div >= 1; div /= 10)
-    {
-        int64_t digit = v / div;
-        v %= div;
-        if ((digit != 0) || (div == 1))
-        {
-            printing = true;
-        }
-        if (printing)
-        {
-            buffer[sz++] = digit + '0';
-        }
-    }
-    return sz;
-}
-
-static size_t format_udec(char * buffer, int32_t v)
-{
-    size_t sz = 0u;
-    for (int32_t div = 1000000000u; div >= 1u; div /= 10u)
-    {
-        int32_t digit = v / div;
-        v %= div;
-        if ((digit != 0) || (sz > 0u) || (div == 1))
-        {
-            buffer[sz++] = digit + '0';
-        }
-    }
-    return sz;
-}
-
-static size_t format_udec64(char * buffer, uint64_t v)
-{
-    size_t sz = 0u;
-    for (uint64_t div = 10000000000000000000u; div >= 1u; div /= 10u)
-    {
-        uint64_t digit = v / div;
-        v %= div;
-        if ((digit != 0) || (sz > 0u) || (div == 1))
-        {
-            buffer[sz++] = digit + '0';
-        }
-    }
-    return sz;
-}
-
-static size_t format_hex(char * buffer, uint32_t v, bool upper)
-{
-    const char upper_hex[] = "0123456789ABCDEF";
-    const char lower_hex[] = "0123456789abcdef";
-    size_t sz = 0u;
-    for (int i = 28; i >= 0; i -= 4)
-    {
-        uint8_t n = (v >> i) & 0xFu;
-        if ((sz > 0u) || (n != 0u) || (i == 0))
-        {
-            buffer[sz] = upper ? upper_hex[n] : lower_hex[n];
-            sz++;
-        }
-    }
-    return sz;
-}
-
-static size_t format_hex64(char * buffer, uint64_t v, bool upper)
-{
-    const char upper_hex[] = "0123456789ABCDEF";
-    const char lower_hex[] = "0123456789abcdef";
-    size_t sz = 0u;
-    for (int i = 60; i >= 0; i -= 4)
-    {
-        uint8_t n = (v >> i) & 0xFu;
-        if ((sz > 0u) || (n != 0u) || (i == 0))
-        {
-            buffer[sz] = upper ? upper_hex[n] : lower_hex[n];
-            sz++;
-        }
-    }
-    return sz;
-}
-
-static void pad_write(const stream_t * stream, const char * data, size_t length, bool leading_zero, bool left_just, size_t width)
-{
-    if (left_just)
-    {
-        stream->write(data, length);
-        while (length < width)
-        {
-            stream->write1(' ');
-            length++;
-        }
-    }
-    else
-    {
-        char fill = leading_zero ? '0' : ' ';
-        size_t l = length;
-        while (l < width)
-        {
-            stream->write1(fill);
-            l++;
-        }
-        stream->write(data, length);
-    }
-}
-
-void hos_vprintf(const stream_t * stream, const char * fmt, va_list va)
-{
-    bool in_conv = false;
-    char c;
-    char buffer[22];
-    size_t width;
-    bool leading_zero;
-    bool left_just;
-    bool long_flag;
-    size_t length;
-    while ((c = *fmt))
-    {
-        if (in_conv)
-        {
-            switch (c)
-            {
-            case '%':
-                stream->write1('%');
-                break;
-            case 'X':
-                {
-                    if (long_flag)
-                    {
-                        uint64_t v = va_arg(va, uint64_t);
-                        length = format_hex(buffer, v, true);
-                    }
-                    else
-                    {
-                        uint32_t v = va_arg(va, uint32_t);
-                        length = format_hex(buffer, v, true);
-                    }
-                    pad_write(stream, buffer, length, leading_zero, left_just, width);
-                }
-                break;
-            case 'c':
-                {
-                    char ch = va_arg(va, int);
-                    pad_write(stream, &ch, 1u, leading_zero, left_just, width);
-                }
-                break;
-            case 'd':
-                {
-                    if (long_flag)
-                    {
-                        int64_t v = va_arg(va, int64_t);
-                        length = format_dec64(buffer, v);
-                    }
-                    else
-                    {
-                        int32_t v = va_arg(va, int32_t);
-                        length = format_dec(buffer, v);
-                    }
-                    pad_write(stream, buffer, length, leading_zero, left_just, width);
-                }
-                break;
-            case 's':
-                {
-                    const char * s = va_arg(va, const char *);
-                    pad_write(stream, s, strlen(s), leading_zero, left_just, width);
-                }
-                break;
-            case 'u':
-                {
-                    if (long_flag)
-                    {
-                        uint64_t v = va_arg(va, uint64_t);
-                        length = format_udec64(buffer, v);
-                    }
-                    else
-                    {
-                        uint32_t v = va_arg(va, uint32_t);
-                        length = format_udec(buffer, v);
-                    }
-                    pad_write(stream, buffer, length, leading_zero, left_just, width);
-                }
-                break;
-            case 'x':
-                {
-                    if (long_flag)
-                    {
-                        uint64_t v = va_arg(va, uint64_t);
-                        length = format_hex64(buffer, v, false);
-                    }
-                    else
-                    {
-                        uint32_t v = va_arg(va, uint32_t);
-                        length = format_hex(buffer, v, false);
-                    }
-                    pad_write(stream, buffer, length, leading_zero, left_just, width);
-                }
-                break;
-            }
-            in_conv = false;
-        }
-        else if (c == '%')
-        {
-            in_conv = true;
-            width = 0u;
-            leading_zero = false;
-            left_just = false;
-            long_flag = false;
-            if (fmt[1] == '-')
-            {
-                left_just = true;
-                fmt++;
-            }
-            if (fmt[1] == '0')
-            {
-                leading_zero = true;
-                fmt++;
-            }
-            while (('0' <= fmt[1]) && (fmt[1] <= '9'))
-            {
-                width *= 10u;
-                width += (fmt[1] - '0');
-                fmt++;
-            }
-            if (fmt[1] == 'l')
-            {
-                long_flag = true;
-                fmt++;
-            }
-        }
-        else
-        {
-            stream->write1(c);
-        }
-        fmt++;
-    }
-}
-
-void hos_printf(const stream_t * stream, const char * fmt, ...)
-{
-    va_list va;
-    va_start(va, fmt);
-    hos_vprintf(stream, fmt, va);
-    va_end(va);
-}

src/hos_printf.h

@@ -1,10 +0,0 @@
-#ifndef HOS_PRINTF_H
-#define HOS_PRINTF_H
-
-#include "stream.h"
-#include <stdarg.h>
-
-void hos_vprintf(const stream_t * stream, const char * fmt, va_list va);
-void hos_printf(const stream_t * stream, const char * fmt, ...);
-
-#endif

src/hulk/acpi.d

@@ -0,0 +1,159 @@
+/**
+ * ACPI (Advanced Configuration and Power Interface) functionality.
+ */
+module hulk.acpi;
+
+import hulk.hurl;
+import hulk.klog;
+import hulk.memory;
+
+struct Acpi
+{
+    static uint signature(string s)
+    {
+        return s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
+    }
+
+    enum uint APIC_SIGNATURE = signature("APIC");
+    enum uint MCFG_SIGNATURE = signature("MCFG");
+    enum uint XSDT_SIGNATURE = signature("XSDT");
+
+    static align(4) struct Header
+    {
+        uint signature;
+        uint length;
+        ubyte revision;
+        ubyte checksum;
+        char[6] oemid;
+        ulong oemtableid;
+        uint oem_revision;
+        uint creator_id;
+        uint creator_revision;
+    }
+
+    static struct XSDT
+    {
+        Header header;
+        /* Table pointers are not ulong-aligned! They begin at offset 36. */
+        align(4) ulong[1] tables;
+    }
+
+    static struct MADT
+    {
+        static struct Entry
+        {
+            enum LOCAL_APIC_ADDRESS_OVERRIDE = 5;
+
+            ubyte type;
+            ubyte length;
+        }
+
+        Header header;
+        uint local_apic_address;
+        uint flags;
+
+        void initialize()
+        {
+            apic_address = local_apic_address;
+            Klog.writefln("Found 32-bit APIC address: 0x%x", apic_address);
+            const(void) * end = cast(const(void) *)(&this) + header.length;
+            const(Entry) * entry = cast(const(Entry) *)(cast(ulong)&this + MADT.sizeof);
+            while (entry < end)
+            {
+                entry = cast(const(Entry) *)(cast(size_t)entry + entry.length);
+                if (entry.type == Entry.LOCAL_APIC_ADDRESS_OVERRIDE)
+                {
+                    /* Found a 64-bit Local APIC Address Override entry. */
+                    Klog.writefln("Found 64-bit APIC address: 0x%x", apic_address);
+                    memcpy(cast(void *)&apic_address, cast(const(void) *)entry + 4u, apic_address.sizeof);
+                }
+            }
+        }
+    }
+
+    static struct MCFG
+    {
+        /* PCI Segment Group Memory Area Descriptor. */
+        static struct SGMADesc
+        {
+            uint[2] base_address_a;
+            ushort pci_segment_group_number;
+            ubyte start_pci_bus_number;
+            ubyte end_pci_bus_number;
+            uint _reserved;
+
+            public @property ulong base_address() const
+            {
+                return base_address_a[0] | (cast(ulong)base_address_a[1] << 32);
+            }
+        }
+        static assert(SGMADesc.sizeof == 16);
+        static assert(SGMADesc.alignof == 4);
+
+        Header header;
+        uint[2] _reserved;
+        SGMADesc[0] sgma_descs;
+
+        void initialize()
+        {
+            Klog.writefln("MCFG length = %u", header.length);
+            size_t n_sgma_descs = (header.length - MCFG.sgma_descs.offsetof) / MCFG.SGMADesc.sizeof;
+            Klog.writefln("# SGMA descriptors = %u", (header.length - MCFG.sgma_descs.offsetof) / MCFG.SGMADesc.sizeof);
+            for (size_t i = 0; i < n_sgma_descs; i++)
+            {
+                Klog.writefln("SGMA %u: SG %u; Bus %u-%u; addr %p",
+                        i,
+                        sgma_descs[i].pci_segment_group_number,
+                        sgma_descs[i].start_pci_bus_number,
+                        sgma_descs[i].end_pci_bus_number,
+                        sgma_descs[i].base_address);
+            }
+        }
+    }
+
+    public static __gshared ulong apic_address;
+
+    public static void initialize(ulong acpi_xsdt_phys)
+    {
+        /* Map the XSDT header. */
+        Hurl.identity_map_range(acpi_xsdt_phys, PAGE_SIZE, 0u);
+        const(XSDT) * xsdt = cast(const(XSDT) *)acpi_xsdt_phys;
+        if (xsdt.header.signature != XSDT_SIGNATURE)
+        {
+            Klog.writef("XSDT signature invalid\n");
+            return;
+        }
+        /* Map the entire XSDT. */
+        if (xsdt.header.length > PAGE_SIZE)
+        {
+            Hurl.identity_map_range(acpi_xsdt_phys, xsdt.header.length, 0u);
+        }
+        size_t n_entries = (xsdt.header.length - xsdt.header.sizeof) / xsdt.tables[0].sizeof;
+        for (size_t i = 0u; i < n_entries; i++)
+        {
+            ulong address = xsdt.tables[i];
+            Hurl.identity_map_range(address, PAGE_SIZE, 0u);
+            const(Header) * header = cast(const(Header) *)address;
+            uint length = header.length;
+            if (length > PAGE_SIZE)
+            {
+                Hurl.identity_map_range(address, length, 0u);
+            }
+            uint signature = header.signature;
+            Klog.writefln("Found ACPI table %08x (%c%c%c%c)",
+                    signature,
+                    signature & 0xFFu,
+                    (signature >> 8u) & 0xFFu,
+                    (signature >> 16u) & 0xFFu,
+                    (signature >> 24u) & 0xFFu);
+            if (signature == APIC_SIGNATURE)
+            {
+                (cast(MADT *)address).initialize();
+            }
+            else if (signature == MCFG_SIGNATURE)
+            {
+                (cast(MCFG *)address).initialize();
+            }
+        }
+    }
+}

src/hulk/apic.d

@@ -0,0 +1,114 @@
+/**
+ * APIC (Advanced Programmable Interrupt Controller) functionality.
+ */
+module hulk.apic;
+
+import hulk.klog;
+import hulk.hurl;
+import hulk.acpi;
+import hulk.idt;
+import hulk.rtc;
+
+struct Apic
+{
+    private enum uint PERIODIC_MODE = 0x2_0000u;
+
+    private enum ulong IRQ_RTC = 8u;
+
+    static struct ApicRegister
+    {
+        public uint value;
+        alias value this;
+
+        private ubyte[12] _padding;
+    }
+
+    static struct ApicRegisters
+    {
+        ApicRegister[2] _reserved0;
+        ApicRegister lapic_id;
+        ApicRegister lapic_version;
+        ApicRegister[4] _reserved1;
+        ApicRegister task_priority;
+        ApicRegister arbitration_priority;
+        ApicRegister processor_priority;
+        ApicRegister eoi;
+        ApicRegister remote_read;
+        ApicRegister logical_destination;
+        ApicRegister destination_format;
+        ApicRegister spurious_interrupt_vector;
+        ApicRegister[8] in_service;
+        ApicRegister[8] trigger_mode;
+        ApicRegister[8] interrupt_request;
+        ApicRegister error_status;
+        ApicRegister[6] _reserved2;
+        ApicRegister lvt_cmci;
+        ApicRegister[2] interrupt_command;
+        ApicRegister lvt_timer;
+        ApicRegister lvt_thermal_sensor;
+        ApicRegister lvt_performance_monitoring_counters;
+        ApicRegister[2] lvt_lint;
+        ApicRegister lvt_error;
+        ApicRegister initial_count;
+        ApicRegister current_count;
+        ApicRegister[4] _reserved3;
+        ApicRegister divide_configuration;
+    }
+
+    static struct IoApicRegisters
+    {
+        ApicRegister address;
+        ApicRegister data;
+    }
+
+    private static __gshared ApicRegisters * apic_registers;
+    private static __gshared IoApicRegisters * io_apic_registers;
+
+    public static void initialize()
+    {
+        apic_registers = cast(ApicRegisters *)Acpi.apic_address;
+        io_apic_registers = cast(IoApicRegisters *)0xFEC0_0000u;
+        Hurl.map(cast(ulong)apic_registers, cast(ulong)apic_registers,
+                PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
+        Hurl.map(cast(ulong)io_apic_registers, cast(ulong)io_apic_registers,
+                PT_WRITABLE | PT_WRITE_THROUGH | PT_DISABLE_CACHE | PT_NO_EXECUTE);
+        Klog.writefln("LAPIC ID: 0x%08x", apic_registers.lapic_id.value);
+        Klog.writefln("LAPIC version: 0x%08x", apic_registers.lapic_version.value);
+        /* Enable local APIC to receive interrupts and set spurious interrupt
+         * vector to 0xFF. */
+        apic_registers.spurious_interrupt_vector.value = 0x100u | Idt.INT_APIC_SPURIOUS;
+        apic_registers.lvt_timer.value = Idt.INT_APIC_TIMER;
+        apic_registers.lvt_lint[0].value = Idt.INT_APIC_LINT0;
+        apic_registers.lvt_lint[1].value = Idt.INT_APIC_LINT1;
+        /* Enable RTC interrupt. */
+        configure_io_apic_irq(IRQ_RTC, Idt.INT_APIC_BASE + IRQ_RTC);
+    }
+
+    private static void configure_io_apic_irq(size_t io_apic_irq, size_t interrupt_id)
+    {
+        ulong entry = interrupt_id;
+        io_apic_registers.address.value = cast(uint)(0x10u + io_apic_irq * 2u);
+        io_apic_registers.data.value = entry & 0xFFFF_FFFFu;
+        io_apic_registers.address.value = cast(uint)(0x10u + io_apic_irq * 2u + 1u);
+        io_apic_registers.data.value = entry >> 32u;
+    }
+
+    public static void eoi()
+    {
+        apic_registers.eoi.value = 0u;
+    }
+
+    public static void isr(ulong vector)
+    {
+        switch (vector)
+        {
+        case Idt.INT_APIC_BASE + IRQ_RTC:
+            Rtc.isr();
+            break;
+
+        default:
+            break;
+        }
+        eoi();
+    }
+}

src/hulk/bootinfo.d

@@ -0,0 +1,77 @@
+/**
+ * HULK boot information.
+ */
+module hulk.bootinfo;
+
+/**
+ * HULK boot information structure.
+ */
+struct BootInfo
+{
+    /**
+     * Framebuffer description structure.
+     */
+    struct Framebuffer
+    {
+        /** Framebuffer physical base address. */
+        uint * buffer;
+        /** Horizontal resolution. */
+        uint width;
+        /** Vertical resolution. */
+        uint height;
+        /** Number of pixels per scan line. */
+        uint stride;
+        /** Pixel format. */
+        uint format;
+    }
+
+    /**
+     * Memory map entry description structure.
+     */
+    struct MemoryRegion
+    {
+        enum Type
+        {
+            Reserved,
+            Bootloader,
+            Conventional,
+            Unusable,
+            ACPIReclaim,
+            ACPINVS,
+            MemoryMappedIO,
+            MemoryMappedIOPortSpace,
+            PalCode,
+        }
+
+        /** Base address of the memory region. */
+        ulong base;
+        /** Size in bytes of the memory region. */
+        size_t size;
+        /** Type of the memory region. */
+        ubyte type;
+    }
+
+    /* Framebuffer parameters. */
+    Framebuffer fb;
+
+    /* Memory map. */
+    MemoryRegion[1000] memory_map;
+
+    /* Number of memory map entries. */
+    size_t memory_map_count;
+
+    /* Physical address of HULK. */
+    ulong hulk_phys;
+
+    /* Physical address used for HULK bss section. */
+    ulong bss_phys;
+
+    /* Physical address of stack while jumping to HULK. */
+    ulong stack_phys;
+
+    /* Physical address of framebuffer buffer1. */
+    ulong fb_buffer1_phys;
+
+    /* Physical address of ACPI XSDT table. */
+    ulong acpi_xsdt_phys;
+}

src/hulk/console.d

@@ -0,0 +1,107 @@
+/**
+ * HULK Console functionality.
+ */
+module hulk.console;
+
+import hulk.fb;
+import hulk.kfont;
+
+/**
+ * Represent the HULK console.
+ *
+ * Coordinate (0,0) is the top-left console position.
+ */
+struct Console
+{
+    /** Console width in text columns. */
+    private static __gshared size_t m_width;
+
+    /** Console height in text rows. */
+    private static __gshared size_t m_height;
+
+    /** Current console cursor X position. */
+    private static __gshared size_t m_x;
+
+    /** Current console cursor Y position. */
+    private static __gshared size_t m_y;
+
+    /**
+     * Initialize the console.
+     */
+    public static void initialize()
+    {
+        m_width = Fb.width / Kfont.advance;
+        m_height = Fb.height / Kfont.line_height;
+    }
+
+    /**
+     * Clear the console.
+     */
+    public static void clear()
+    {
+        Fb.clear();
+        m_x = 0u;
+        m_y = 0u;
+    }
+
+    /**
+     * Write a character to the console.
+     *
+     * @param ch Character to write.
+     */
+    public static void write(char ch)
+    {
+        if (ch == '\n')
+        {
+            m_x = 0u;
+            m_y++;
+        }
+        else
+        {
+            render_char(m_x, m_y, ch);
+            m_x++;
+            if (m_x == m_width)
+            {
+                m_x = 0u;
+                m_y++;
+            }
+        }
+        if (m_y == m_height)
+        {
+            m_y--;
+            Fb.copy_rows_up(fb_y(1u),
+                    (m_height - 1u) * Kfont.line_height,
+                    Kfont.line_height);
+            Fb.rect(0u, fb_y(m_height - 1u), fb_x(m_width), Kfont.line_height, 0u);
+        }
+    }
+
+    /**
+     * Render a character.
+     *
+     * @param x X position.
+     * @param y Y position.
+     * @param ch Character to render.
+     */
+    private static void render_char(size_t x, size_t y, char ch)
+    {
+        const(CharInfo) * ci = &Kfont.chars[ch];
+        Fb.blit_alpha_bitmap(fb_x(x) + ci.left, fb_y(y) + ci.top, ci.bitmap, ci.width, ci.height);
+    }
+
+    /**
+     * Get the framebuffer X coordinate corresponding to the console X position.
+     */
+    private static size_t fb_x(size_t x)
+    {
+        return x * Kfont.advance;
+    }
+
+    /**
+     * Get the framebuffer Y coordinate corresponding to the console Y position.
+     */
+    private static size_t fb_y(size_t y)
+    {
+        return y * Kfont.line_height;
+    }
+}

src/hulk/cpu.d

@@ -0,0 +1,247 @@
+/**
+ * CPU functionality.
+ */
+module hulk.cpu;
+
+import ldc.llvmasm;
+
+/** CR0 bits. @{ */
+enum ulong CR0_PE = 0x1u;
+enum ulong CR0_MP = 0x2u;
+enum ulong CR0_EM = 0x4u;
+enum ulong CR0_TS = 0x8u;
+enum ulong CR0_ET = 0x10u;
+enum ulong CR0_NE = 0x20u;
+enum ulong CR0_WP = 0x1_0000u;
+enum ulong CR0_AM = 0x4_0000u;
+enum ulong CR0_NW = 0x2000_0000u;
+enum ulong CR0_CD = 0x4000_0000u;
+enum ulong CR0_PG = 0x8000_0000u;
+/** @} */
+
+/** CR4 bits. @{ */
+enum ulong CR4_VME = 0x1u;
+enum ulong CR4_PVI = 0x2u;
+enum ulong CR4_TSD = 0x4u;
+enum ulong CR4_DE = 0x8u;
+enum ulong CR4_PSE = 0x10u;
+enum ulong CR4_PAE = 0x20u;
+enum ulong CR4_MCE = 0x40u;
+enum ulong CR4_PGE = 0x80u;
+enum ulong CR4_PCE = 0x100u;
+enum ulong CR4_OSFXSR = 0x200u;
+enum ulong CR4_OSXMMEXCPT = 0x400u;
+enum ulong CR4_UMIP = 0x800u;
+enum ulong CR4_VMXE = 0x2000u;
+enum ulong CR4_SMXE = 0x4000u;
+enum ulong CR4_FSGSBASE = 0x1_0000u;
+enum ulong CR4_PCIDE = 0x2_0000u;
+enum ulong CR4_OSXSAVE = 0x4_0000u;
+enum ulong CR4_SMEP = 0x10_0000u;
+enum ulong CR4_SMAP = 0x20_0000u;
+enum ulong CR4_PKE = 0x40_0000u;
+enum ulong CR4_CET = 0x80_0000u;
+enum ulong CR4_PKS = 0x100_0000u;
+/** @} */
+
+/** XCR0 bits. @{ */
+enum ulong XCR0_X87 = 0x1u;
+enum ulong XCR0_SSE = 0x2u;
+enum ulong XCR0_AVX = 0x4u;
+enum ulong XCR0_BNDREG = 0x8u;
+enum ulong XCR0_BNDSCR = 0x10u;
+enum ulong XCR0_OPMASK = 0x20u;
+enum ulong XCR0_ZMM_HI256 = 0x40u;
+enum ulong XCR0_HI16_ZMM = 0x80u;
+enum ulong XCR0_PKRU = 0x100u;
+/** @} */
+
+/** MSR register numbers. @{ */
+enum uint MSR_EFER = 0xC000_0080u;
+/** @} */
+
+/** EFER flags. @{ */
+enum uint EFER_SCE = 0x1u;
+enum uint EFER_LME = 0x100u;
+enum uint EFER_LMA = 0x400u;
+enum uint EFER_NXE = 0x800u;
+enum uint EFER_SVME = 0x1000u;
+enum uint EFER_LMSLE = 0x2000u;
+enum uint EFER_FFXSR = 0x4000u;
+enum uint EFER_TCE = 0x8000u;
+/** @} */
+
+/** CPUID 1 bits. @{ */
+enum uint CPUID_1_EDX_FPU = 0x1u;
+enum uint CPUID_1_EDX_VME = 0x2u;
+enum uint CPUID_1_EDX_DE = 0x4u;
+enum uint CPUID_1_EDX_PSE = 0x8u;
+enum uint CPUID_1_EDX_TSC = 0x10u;
+enum uint CPUID_1_EDX_MSR = 0x20u;
+enum uint CPUID_1_EDX_PAE = 0x40u;
+enum uint CPUID_1_EDX_MCE = 0x80u;
+enum uint CPUID_1_EDX_CX8 = 0x100u;
+enum uint CPUID_1_EDX_APIC = 0x200u;
+enum uint CPUID_1_EDX_SEP = 0x800u;
+enum uint CPUID_1_EDX_MTRR = 0x1000u;
+enum uint CPUID_1_EDX_PGE = 0x2000u;
+enum uint CPUID_1_EDX_MCA = 0x4000u;
+enum uint CPUID_1_EDX_CMOV = 0x8000u;
+enum uint CPUID_1_EDX_PAT = 0x1_0000u;
+enum uint CPUID_1_EDX_PSE36 = 0x2_0000u;
+enum uint CPUID_1_EDX_PSN = 0x4_0000u;
+enum uint CPUID_1_EDX_CLFSH = 0x8_0000u;
+enum uint CPUID_1_EDX_DS = 0x20_0000u;
+enum uint CPUID_1_EDX_ACPI = 0x40_0000u;
+enum uint CPUID_1_EDX_MMX = 0x80_0000u;
+enum uint CPUID_1_EDX_FXSR = 0x100_0000u;
+enum uint CPUID_1_EDX_SSE = 0x200_0000u;
+enum uint CPUID_1_EDX_SSE2 = 0x400_0000u;
+enum uint CPUID_1_EDX_SS = 0x800_0000u;
+enum uint CPUID_1_EDX_HTT = 0x1000_0000u;
+enum uint CPUID_1_EDX_TM = 0x2000_0000u;
+enum uint CPUID_1_EDX_IA64 = 0x4000_0000u;
+enum uint CPUID_1_EDX_PBE = 0x8000_0000u;
+enum uint CPUID_1_ECX_SSE3 = 0x1u;
+enum uint CPUID_1_ECX_PCLMULQDQ = 0x2u;
+enum uint CPUID_1_ECX_DTES64 = 0x4u;
+enum uint CPUID_1_ECX_MONITOR = 0x8u;
+enum uint CPUID_1_ECX_DSCPL = 0x10u;
+enum uint CPUID_1_ECX_VMX = 0x20u;
+enum uint CPUID_1_ECX_SMX = 0x40u;
+enum uint CPUID_1_ECX_EST = 0x80u;
+enum uint CPUID_1_ECX_TM2 = 0x100u;
+enum uint CPUID_1_ECX_SSSE3 = 0x200u;
+enum uint CPUID_1_ECX_CNXTID = 0x400u;
+enum uint CPUID_1_ECX_SDBG = 0x800u;
+enum uint CPUID_1_ECX_FMA = 0x1000u;
+enum uint CPUID_1_ECX_CX16 = 0x2000u;
+enum uint CPUID_1_ECX_XTPR = 0x4000u;
+enum uint CPUID_1_ECX_PDCM = 0x8000u;
+enum uint CPUID_1_ECX_PCID = 0x2_0000u;
+enum uint CPUID_1_ECX_DCA = 0x4_0000u;
+enum uint CPUID_1_ECX_SSE41 = 0x8_0000u;
+enum uint CPUID_1_ECX_SSE42 = 0x10_0000u;
+enum uint CPUID_1_ECX_X2APIC = 0x20_0000u;
+enum uint CPUID_1_ECX_MOVBE = 0x40_0000u;
+enum uint CPUID_1_ECX_POPCNT = 0x80_0000u;
+enum uint CPUID_1_ECX_TSCDEADLINE = 0x100_0000u;
+enum uint CPUID_1_ECX_AES = 0x200_0000u;
+enum uint CPUID_1_ECX_XSAVE = 0x400_0000u;
+enum uint CPUID_1_ECX_OSXSAVE = 0x800_0000u;
+enum uint CPUID_1_ECX_AVX = 0x1000_0000u;
+enum uint CPUID_1_ECX_F16C = 0x2000_0000u;
+enum uint CPUID_1_ECX_RDRND = 0x4000_0000u;
+enum uint CPUID_1_ECX_HYPERVISOR = 0x8000_0000u;
+/** @} */
+
+void cli()
+{
+    __asm("cli", "");
+}
+
+void sti()
+{
+    __asm("sti", "");
+}
+
+void hlt()
+{
+    __asm("hlt", "");
+}
+
+ulong read_cr0()
+{
+    return __asm!ulong("mov %cr0, %rax", "={rax}");
+}
+
+void write_cr0(ulong v)
+{
+    __asm("mov $0, %cr0", "r", v);
+}
+
+ulong read_cr2()
+{
+    return __asm!ulong("mov %cr2, %rax", "={rax}");
+}
+
+ulong read_cr3()
+{
+    return __asm!ulong("mov %cr3, %rax", "={rax}");
+}
+
+void write_cr3(ulong v)
+{
+    __asm("mov $0, %cr3", "r", v);
+}
+
+ulong read_cr4()
+{
+    return __asm!ulong("mov %cr4, %rax", "={rax}");
+}
+
+void write_cr4(ulong v)
+{
+    __asm("mov $0, %cr4", "r", v);
+}
+
+ulong rdmsr(uint msr)
+{
+    return __asm!ulong(`
+            rdmsr
+            shl $$32, %rdx
+            or %rdx, %rax`, "={rax},{ecx},~{rdx}", msr);
+}
+
+void wrmsr(uint msr, ulong value)
+{
+    __asm(`wrmsr`, "{ecx},{edx},{eax}", msr, value >> 32u, value);
+}
+
+ulong xgetbv(uint xcr)
+{
+    return __asm!ulong(`
+            xgetbv
+            shl $$32, %rdx
+            or %rdx, %rax`, "={rax},{ecx},~{rdx}", xcr);
+}
+
+void xsetbv(uint xcr, ulong value)
+{
+    __asm(`xsetbv`, "{ecx},{edx},{eax}", xcr, value >> 32u, value);
+}
+
+ubyte in8(ushort ioaddr)
+{
+    return __asm!ubyte("inb %dx, %al", "={al},{dx}", ioaddr);
+}
+
+ushort in16(ushort ioaddr)
+{
+    return __asm!ushort("inw %dx, %ax", "={ax},{dx}", ioaddr);
+}
+
+uint in32(ushort ioaddr)
+{
+    return __asm!uint("inl %dx, %eax", "={eax},{dx}", ioaddr);
+}
+
+void out8(ushort ioaddr, ubyte v)
+{
+    __asm("outb %al, %dx", "{dx},{al}", ioaddr, v);
+}
+
+void out16(ushort ioaddr, ushort v)
+{
+    __asm("outw %ax, %dx", "{dx},{ax}", ioaddr, v);
+}
+
+void out32(ushort ioaddr, uint v)
+{
+    __asm("outl %eax, %dx", "{dx},{eax}", ioaddr, v);
+}
+
+void cpuid1(uint * ebx, uint * ecx, uint * edx)
+{
+    __asm("cpuid", "=*{ebx},=*{ecx},=*{edx},{eax}", ebx, ecx, edx, 1u);
+}

src/hulk/fb.d

@@ -0,0 +1,214 @@
+/**
+ * HULK Framebuffer support.
+ */
+module hulk.fb;
+
+import hulk.memory;
+import hulk.kfont;
+
+/**
+ * Represent a graphical frame buffer.
+ *
+ * Coordinate (0,0) is the top-left corner of the framebuffer.
+ *
+ * TODO: Handle other pixel formats. Currently only BGRx is supported.
+ */
+struct Fb
+{
+    /** Device frame buffer base address. */
+    private __gshared static uint * m_device_buffer;
+
+    /** Frame buffer 1 base address. */
+    private __gshared static uint * m_buffer1;
+
+    /** Frame buffer width. */
+    private __gshared static uint m_width;
+
+    /** Frame buffer height. */
+    private __gshared static uint m_height;
+
+    /** Frame buffer stride. */
+    private __gshared static uint m_stride;
+
+    /** Number of pixels in the frame buffer (whether visible or not). */
+    private __gshared static uint m_buffer_size;
+
+    /**
+     * Get the framebuffer width.
+     */
+    public static @property uint width()
+    {
+        return m_width;
+    }
+
+    /**
+     * Get the framebuffer height.
+     */
+    public static @property uint height()
+    {
+        return m_height;
+    }
+
+    /**
+     * Initialize a frame buffer.
+     *
+     * @param device_buffer Device frame buffer base address.
+     * @param buffer1 Frame buffer 1 base address.
+     * @param width Frame buffer width.
+     * @param height Frame buffer height.
+     * @param stride Frame buffer stride.
+     */
+    static void initialize(uint * device_buffer, uint * buffer1, uint width, uint height, uint stride)
+    {
+        m_device_buffer = device_buffer;
+        m_buffer1 = buffer1;
+        m_width = width;
+        m_height = height;
+        m_stride = stride;
+        m_buffer_size = stride * height;
+    }
+
+    /**
+     * Clear the frame buffer to the given color.
+     *
+     * @param color Color to clear to.
+     */
+    static void clear(uint color = 0u)
+    {
+        memset32(m_buffer1, color, m_buffer_size);
+        memset32(m_device_buffer, color, m_buffer_size);
+    }
+
+    /**
+     * Draw a solid rectangle on the framebuffer.
+     *
+     * @param x X coordinate of left of rectangle.
+     * @param y Y coordinate of top of rectangle.
+     * @param width Width of rectangle.
+     * @param height Height of rectangle.
+     * @param color Color of rectangle.
+     */
+    static void rect(size_t x, size_t y, size_t width, size_t height, uint color)
+    {
+        for (size_t iy = 0u; iy < height; iy++)
+        {
+            size_t buffer_index = buffer_index(x, y);
+            memset32(&m_buffer1[buffer_index], color, width);
+            memset32(&m_device_buffer[buffer_index], color, width);
+            y++;
+        }
+    }
+
+    /**
+     * Draw a horizontal line.
+     *
+     * @param x X coordinate of left of line.
+     * @param y Y coordinate of line.
+     * @param width Width of line.
+     * @param color Color of line.
+     */
+    static void hline(size_t x, size_t y, size_t width, uint color)
+    {
+        size_t buffer_index = buffer_index(x, y);
+        memset32(&m_buffer1[buffer_index], color, width);
+        memset32(&m_device_buffer[buffer_index], color, width);
+    }
+
+    /**
+     * Draw a vertical line.
+     *
+     * @param x X coordinate of line.
+     * @param y Y coordinate of top of line.
+     * @param height Height of line.
+     * @param color Color of line.
+     */
+    static void vline(size_t x, size_t y, size_t height, uint color)
+    {
+        size_t buffer_index = buffer_index(x, y);
+        for (size_t iy = 0u; iy < height; iy++)
+        {
+            m_buffer1[buffer_index] = color;
+            m_device_buffer[buffer_index] = color;
+            buffer_index += m_stride;
+        }
+    }
+
+    /**
+     * Blit an 8-bit alpha bitmap to the framebuffer.
+     * The foreground will be white (based on the alpha value), and the
+     * background black.
+     *
+     * @param x X coordinate of left of target location.
+     * @param y Y coordinate of top of target location.
+     * @param alpha_bitmap 8-bit alpha-channel bitmap.
+     * @param width Bitmap width.
+     * @param height Bitmap height.
+     */
+    static void blit_alpha_bitmap(size_t x, size_t y, const(ubyte) * alpha_bitmap,
+            size_t width, size_t height)
+    {
+        size_t bitmap_index;
+        for (size_t iy = 0u; iy < height; iy++)
+        {
+            size_t row_buffer_index = buffer_index(x, y);
+            for (size_t ix = 0u; ix < width; ix++)
+            {
+                size_t buffer_index = row_buffer_index + ix;
+                ubyte alpha = alpha_bitmap[bitmap_index];
+                m_buffer1[buffer_index] = (alpha << 16u) | (alpha << 8u) | alpha;
+                bitmap_index++;
+            }
+            memcpy32(&m_device_buffer[row_buffer_index], &m_buffer1[row_buffer_index], width);
+            y++;
+        }
+    }
+
+    /**
+     * Blit an 8-bit alpha bitmap to the framebuffer.
+     * The foreground will be white (based on the alpha value), and the
+     * background black.
+     *
+     * @param x X coordinate of left of target location.
+     * @param y Y coordinate of top of target location.
+     * @param alpha_bitmap 8-bit alpha-channel bitmap.
+     * @param width Bitmap width.
+     * @param height Bitmap height.
+     */
+    static void blit_alpha_bitmap(size_t x, size_t y, const(ubyte)[] alpha_bitmap,
+            size_t width, size_t height)
+    {
+        blit_alpha_bitmap(x, y, alpha_bitmap.ptr, width, height);
+    }
+
+    /**
+     * Copy framebuffer rows up in the framebuffer.
+     *
+     * @param y Y coordinate of top of region to copy up.
+     * @param height Height of region to copy up.
+     * @param offset Number of rows to copy region up by.
+     */
+    static void copy_rows_up(size_t y, size_t height, size_t offset)
+    {
+        size_t dest_buffer_index = buffer_index(0u, y - offset);
+        size_t src_buffer_index = buffer_index(0u, y);
+        memcpy32(&m_buffer1[dest_buffer_index],
+                 &m_buffer1[src_buffer_index],
+                 (m_stride * height));
+        memcpy32(&m_device_buffer[dest_buffer_index],
+                &m_buffer1[dest_buffer_index],
+                (m_stride * height));
+    }
+
+    /**
+     * Return the buffer index for the given X and Y coordinates.
+     *
+     * @param x X coordinate from left side of framebuffer.
+     * @param y Y coordinate from bottom side of framebuffer.
+     *
+     * @return Buffer index for the given X and Y coordinates.
+     */
+    private static size_t buffer_index(size_t x, size_t y)
+    {
+        return y * m_stride + x;
+    }
+}

src/hulk/gdt.d

@@ -0,0 +1,58 @@
+/**
+ * GDT (Global Descriptor Table) functionality.
+ */
+module hulk.gdt;
+
+import ldc.llvmasm;
+
+struct Gdt
+{
+    struct gdtr_t
+    {
+        ushort limit;
+        align(2) ulong offset;
+    }
+    static assert(gdtr_t.sizeof == 10u);
+
+    public enum size_t SELECTOR_NULL = 0x00u;
+    public enum size_t SELECTOR_KERNEL_CODE = 0x08u;
+    public enum size_t SELECTOR_KERNEL_DATA = 0x10u;
+    public enum size_t SELECTOR_COUNT = 3u;
+
+    static __gshared ulong[SELECTOR_COUNT] gdt;
+    static __gshared gdtr_t gdtr;
+
+    public static void initialize()
+    {
+        gdt[SELECTOR_KERNEL_CODE / ulong.sizeof] = 0x00_A_F_9A_000000_0000u;
+        gdt[SELECTOR_KERNEL_DATA / ulong.sizeof] = 0x00_C_F_92_000000_0000u;
+        gdtr.limit = gdt.sizeof - 1u;
+        gdtr.offset = cast(ulong)&gdt;
+        lgdt(&gdtr);
+        load_data_selectors(SELECTOR_KERNEL_DATA);
+        load_code_selector(SELECTOR_KERNEL_CODE);
+    }
+
+    private static void lgdt(gdtr_t * gdtr)
+    {
+        __asm("lgdt $0", "*m", gdtr);
+    }
+
+    private static void load_data_selectors(ulong selector)
+    {
+        __asm(`mov %ax, %ds
+               mov %ax, %es
+               mov %ax, %fs
+               mov %ax, %gs
+               mov %ax, %ss`, "{rax}", selector);
+    }
+
+    private static void load_code_selector(ulong selector)
+    {
+        __asm(`push %rax
+               movabs $$1f, %rax
+               push %rax
+               lretq
+               1:`, "{rax}", selector);
+    }
+}

src/hulk/header.d

@@ -0,0 +1,40 @@
+/**
+ * HULK image header.
+ */
+module hulk.header;
+
+import hulk.bootinfo;
+
+/**
+ * Header describing the HULK image.
+ */
+struct HulkHeader
+{
+    /**
+     * HULK BSS size.
+     *
+     * The OS loader must map memory to a zeroed range of this size.
+     *
+     * This value is really an integer, but is stored as a pointer because it
+     * is provided by the linker and LDC does not like us to cast it.
+     */
+    void * hulk_bss_size;
+
+    /** Entry point. */
+    void * entry;
+
+    /** Stack size. */
+    ulong stack_size;
+
+    /** Virtual base address. */
+    ulong virt_base;
+
+    /** Stack top virtual address. */
+    ulong virt_stack_top;
+
+    /** Framebuffer virtual address. */
+    ulong virt_fb_buffer;
+
+    /** HULK boot information. */
+    BootInfo bootinfo;
+}

src/hulk/hippo.d

@@ -0,0 +1,69 @@
+/**
+ * HIPPO, the HOS In-place Physical Page Organizer.
+ *
+ * HIPPO maintains a list of free physical pages "in place", meaning that the
+ * available page itself is used as the linked list entry so separate memory
+ * is not needed to keep track of the available pages.
+ */
+module hulk.hippo;
+
+struct Hippo
+{
+    /**
+     * Linked list node entry for a physical page.
+     */
+    private static struct PhysicalPage
+    {
+        PhysicalPage * next;
+    }
+
+    /**
+     * Linked list of free physical pages.
+     */
+    private static __gshared PhysicalPage * free_pages;
+
+    /**
+     * Number of free physical pages.
+     */
+    private static __gshared size_t m_n_free_pages;
+
+    /**
+     * Free a physical page.
+     *
+     * @param phys Physical page address.
+     */
+    public static void free_page(T)(T phys)
+    {
+        PhysicalPage * pp = cast(PhysicalPage *)phys;
+        pp.next = free_pages;
+        free_pages = pp;
+        m_n_free_pages++;
+    }
+
+    /**
+     * Allocate a physical page.
+     *
+     * @return Page address, or null if no pages are available.
+     */
+    public static void * allocate_page()
+    {
+        PhysicalPage * pp;
+        if (free_pages != null)
+        {
+            pp = free_pages;
+            free_pages = free_pages.next;
+            m_n_free_pages--;
+        }
+        return cast(void *)pp;
+    }
+
+    /**
+     * Get the number of free pages.
+     *
+     * @return The number of free pages.
+     */
+    public @property size_t n_free_pages() const
+    {
+        return m_n_free_pages;
+    }
+}

src/hulk/hulk.d

@@ -0,0 +1,86 @@
+/**
+ * HULK, the HOS Ultra Light Kernel.
+ */
+module hulk.hulk;
+
+import hulk.header;
+import hulk.fb;
+import hulk.console;
+import hulk.memory;
+import ldc.attributes;
+import hulk.kfont;
+import hulk.klog;
+import hulk.hurl;
+import hulk.hippo;
+import hulk.pci;
+import hulk.gdt;
+import hulk.idt;
+import hulk.cpu;
+import ldc.llvmasm;
+import hulk.pic;
+import hulk.acpi;
+import hulk.apic;
+import hulk.rtc;
+import hulk.serial;
+
+extern extern(C) __gshared ubyte _hulk_bss_size;
+
+@(ldc.attributes.section(".hulk_header"))
+private __gshared HulkHeader hulk_header = {
+    &_hulk_bss_size, /* hulk_bss_size */
+    &hulk_start, /* entry */
+    16u * 1024u, /* stack_size */
+    Hurl.HULK_BASE, /* virt_base */
+    Hurl.HULK_STACK_TOP, /* virt_stack_top */
+    Hurl.HULK_FRAMEBUFFER, /* virt_fb_buffer */
+};
+
+private void initialize_cpu()
+{
+    /* Enable SSE. */
+    /* Turn off CR0.EM and turn on CR0.MP. */
+    write_cr0((read_cr0() & ~CR0_EM) | CR0_MP);
+    /* Set CR4.OSFXSR and CR4.OSXMMEXCPT. */
+    write_cr4(read_cr4() | CR4_OSFXSR | CR4_OSXMMEXCPT);
+
+    /* Enable OSXSAVE. */
+    write_cr4(read_cr4() | CR4_OSXSAVE);
+
+    /* Turn on NXE (no execute enable) flag in the EFER MSR. */
+    wrmsr(MSR_EFER, rdmsr(MSR_EFER) | EFER_NXE);
+}
+
+/**
+ * HULK entry point.
+ */
+void hulk_start()
+{
+    cli();
+    initialize_cpu();
+    Serial.initialize();
+    Gdt.initialize();
+    Idt.initialize();
+    Fb.initialize(cast(uint *)Hurl.HULK_FRAMEBUFFER,
+            cast(uint *)hulk_header.bootinfo.fb_buffer1_phys,
+            hulk_header.bootinfo.fb.width,
+            hulk_header.bootinfo.fb.height,
+            hulk_header.bootinfo.fb.stride);
+    Console.initialize();
+    Console.clear();
+    Klog.initialize();
+
+    Klog.writefln("Welcome to HULK, the HOS UltraLight Kernel!");
+
+    Hurl.initialize(&hulk_header);
+    Pci.initialize();
+    Pic.initialize();
+    Acpi.initialize(hulk_header.bootinfo.acpi_xsdt_phys);
+    Apic.initialize();
+    Rtc.initialize();
+    sti();
+
+    for (;;)
+    {
+        hlt();
+    }
+}

src/hulk/hulk.ld

@@ -0,0 +1,65 @@
+SECTIONS
+{
+    . = 0xFFFF800000000000;
+    _hulk_mem_start = .;
+    _hulk_header_start = .;
+
+    .hulk_header :
+    {
+        KEEP(*(.hulk_header))
+    }
+
+    . = ALIGN(4K);
+    _hulk_header_end = .;
+    _hulk_text_start = .;
+
+    .text :
+    {
+        *(.text)
+        *(.text.*)
+    }
+
+    . = ALIGN(4K);
+    _hulk_text_end = .;
+    _hulk_rodata_start = .;
+
+    .rodata :
+    {
+        *(.rodata)
+        *(.rodata.*)
+    }
+
+    . = ALIGN(4K);
+
+    _hulk_rodata_end = .;
+    _hulk_data_start = .;
+
+    .data :
+    {
+        *(.data)
+        *(.data.*)
+    }
+
+    . = ALIGN(4K);
+    _hulk_data_end = .;
+    _hulk_binary_size = . - _hulk_mem_start;
+    _hulk_bss_start = .;
+
+    .bss :
+    {
+        *(COMMON)
+        *(.bss)
+        *(.bss.*)
+    }
+
+    . = ALIGN(4K);
+    _hulk_bss_end = .;
+    _hulk_mem_end = .;
+
+    _hulk_header_size = _hulk_header_end - _hulk_header_start;
+    _hulk_text_size = _hulk_text_end - _hulk_text_start;
+    _hulk_rodata_size = _hulk_rodata_end - _hulk_rodata_start;
+    _hulk_data_size = _hulk_data_end - _hulk_data_start;
+    _hulk_bss_size = _hulk_bss_end - _hulk_bss_start;
+    _hulk_mem_size = _hulk_mem_end - _hulk_mem_start;
+}

src/hulk/hurl/a1.d

@@ -0,0 +1,64 @@
+/**
+ * A1 memory allocator.
+ */
+module hulk.hurl.a1;
+
+import hulk.hurl;
+import hulk.hippo;
+import hulk.util;
+import hulk.pagetable;
+
+/**
+ * The A1 memory allocator is a one-shot memory allocator for kernel memory
+ * that is allocated but never freed.
+ */
+struct A1
+{
+    /**
+     * Number of bytes allocated in the A1 region so far.
+     */
+    private static __gshared size_t allocated;
+
+    /**
+     * Allocate memory.
+     *
+     * @param size
+     *   Size of memory to allocate.
+     *
+     * @return Address of allocated memory. This address will always be aligned
+     *   to a multiple of 16 bytes.
+     */
+    public static void * allocate(size_t size)
+    {
+        /* Round size up to a multiple of 16. */
+        size = round_up_power_2(size, 16u);
+
+        ulong address = Hurl.A1_BASE + allocated;
+
+        ulong current_limit = round_up_power_2(address, PAGE_SIZE);
+
+        allocated += size;
+
+        ulong desired_limit = round_up_power_2(Hurl.A1_BASE + allocated, PAGE_SIZE);
+
+        while (desired_limit > current_limit)
+        {
+            void * page = Hippo.allocate_page();
+            Hurl.map(current_limit, page, PT_WRITABLE);
+            current_limit += PAGE_SIZE;
+        }
+
+        return cast(void *)address;
+    }
+
+    /**
+     * Allocate memory to store an instance of a given type.
+     *
+     * @return Address of allocated memory. This address will always be aligned
+     *   to a multiple of 16 bytes.
+     */
+    public static T * allocate(T)()
+    {
+        return cast(T *)allocate(T.sizeof);
+    }
+}

src/hulk/hurl/hurl.d

@@ -0,0 +1,315 @@
+/**
+ * HURL, the HOS Unreal Region Locator.
+ *
+ * HURL provides virtual memory management for HULK.
+ */
+module hulk.hurl.hurl;
+
+public import hulk.pagetable;
+import hulk.cpu;
+import hulk.hippo;
+import hulk.memory;
+import hulk.klog;
+import hulk.bootinfo;
+import hulk.header;
+import hulk.linker_addresses;
+import hulk.util;
+
+struct Hurl
+{
+    /** HULK base address. */
+    enum ulong HULK_BASE = 0xFFFF_8000_0000_0000u;
+
+    /** HULK stack top address. */
+    enum ulong HULK_STACK_TOP = 0xFFFF_8001_0000_0000u;
+
+    /** HULK framebuffer address. */
+    enum ulong HULK_FRAMEBUFFER = 0xFFFF_8001_0000_0000u;
+
+    /** A1 allocator range base address. */
+    enum ulong A1_BASE = 0xFFFF_8002_0000_0000u;
+
+    /**
+     * Pointer to the base page table.
+     */
+    private static __gshared PageTable * m_pt_base;
+
+    /**
+     * Build HULK page tables.
+     *
+     * @param physical_address_limit
+     *   Limit of physical memory.
+     */
+    private static void build_page_tables(HulkHeader * header, size_t physical_address_limit)
+    {
+        m_pt_base = allocate_pt();
+        /* Identity map all physical RAM. */
+        map_range(0u,
+                0u,
+                physical_address_limit,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        ulong phys_address = header.bootinfo.hulk_phys;
+        ulong virt_address = HULK_BASE;
+        /* Map HULK header region. */
+        map_range(virt_address,
+                phys_address,
+                LinkerAddresses.hulk_header_size,
+                PT_NO_EXECUTE);
+        phys_address += LinkerAddresses.hulk_header_size;
+        virt_address += LinkerAddresses.hulk_header_size;
+        /* Map HULK text region. */
+        map_range(virt_address,
+                phys_address,
+                LinkerAddresses.hulk_text_size,
+                0u);
+        phys_address += LinkerAddresses.hulk_text_size;
+        virt_address += LinkerAddresses.hulk_text_size;
+        /* Map HULK rodata region. */
+        map_range(virt_address,
+                phys_address,
+                LinkerAddresses.hulk_rodata_size,
+                PT_NO_EXECUTE);
+        phys_address += LinkerAddresses.hulk_rodata_size;
+        virt_address += LinkerAddresses.hulk_rodata_size;
+        /* Map HULK data region. */
+        map_range(virt_address,
+                phys_address,
+                LinkerAddresses.hulk_data_size,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        virt_address += LinkerAddresses.hulk_data_size;
+        /* Map HULK BSS region. */
+        map_range(virt_address,
+                header.bootinfo.bss_phys,
+                LinkerAddresses.hulk_bss_size,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        /* Map HULK stack. */
+        map_range(HULK_STACK_TOP - header.stack_size,
+                header.bootinfo.stack_phys,
+                header.stack_size,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        /* Map device framebuffer. */
+        map_range(HULK_FRAMEBUFFER,
+                cast(ulong)header.bootinfo.fb.buffer,
+                header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        /* Map framebuffer buffer1. */
+        map_range(cast(ulong)header.bootinfo.fb_buffer1_phys,
+                cast(ulong)header.bootinfo.fb_buffer1_phys,
+                header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u,
+                PT_WRITABLE | PT_NO_EXECUTE);
+        write_cr3(cast(ulong)m_pt_base);
+    }
+
+    /**
+     * Reclaim the pages that were used for the bootloader page tables.
+     *
+     * @param pt
+     *   The page table to reclaim pages from.
+     * @param level
+     *   Page table level (internally used while recursing the page tables).
+     *
+     * @return Number of pages reclaimed.
+     */
+    private static size_t reclaim_bootloader_page_table_pages(PageTable * pt, size_t level = 0u)
+    {
+        map(pt, pt, PT_WRITABLE | PT_NO_EXECUTE);
+        size_t reclaimed_pages;
+        for (size_t i = 0u; i < PageTable.N_ENTRIES; i++)
+        {
+            PageTableEntry pte = (*pt)[i];
+            if (pte.present && (level < 2u) && !pte.huge)
+            {
+                /* For the first two levels of page tables, first
+                 * recurse and free pages from the lower level page
+                 * tables before reclaiming this entry. */
+                reclaimed_pages += reclaim_bootloader_page_table_pages(pte.follow(), level + 1u);
+            }
+        }
+        Hippo.free_page(pt);
+        reclaimed_pages++;
+        return reclaimed_pages;
+    }
+
+    /**
+     * Initialize HURL.
+     *
+     * @param bootinfo HULK boot information structure.
+     */
+    public static void initialize(HulkHeader * header)
+    {
+        PageTable * bootloader_pt_base = cast(PageTable *)read_cr3();
+
+        /*
+         * Ok, what we do here is iterate through all of the memory map regions
+         * in the bootinfo memory_map array and mark each page that is not in
+         * use in a reserved range as available. Within the available memory
+         * regions, we have to watch out for the following items:
+         *   1) HULK binary (header + text + rodata + data)
+         *   2) Framebuffer
+         * In addition to these ranges, there are also pages for the following
+         * purposes that are not represented in the memory map from the
+         * bootloader:
+         *   3) HULK BSS
+         *   4) HULK stack
+         *   5) bootloader page table pages
+         *   6) framebuffer buffer1
+         */
+        size_t usable_memory;
+        size_t physical_address_limit;
+        const(size_t) fb_size = round_up_power_2(header.bootinfo.fb.height * header.bootinfo.fb.stride * 4u, PAGE_SIZE);
+        ulong[2][2] reserved = [
+            [header.bootinfo.hulk_phys, LinkerAddresses.hulk_binary_size],
+            [cast(ulong)header.bootinfo.fb.buffer, fb_size],
+        ];
+        for (size_t ri = 0u; ri < reserved.length; ri++)
+        {
+            reserved[ri][1] += reserved[ri][0];
+        }
+        for (size_t bii = 0u; bii < header.bootinfo.memory_map_count; bii++)
+        {
+            if ((header.bootinfo.memory_map[bii].type == BootInfo.MemoryRegion.Type.Bootloader) ||
+                (header.bootinfo.memory_map[bii].type == BootInfo.MemoryRegion.Type.Conventional))
+            {
+                ulong phys = header.bootinfo.memory_map[bii].base;
+                ulong phys_end = phys + header.bootinfo.memory_map[bii].size;
+                if (phys_end > physical_address_limit)
+                {
+                    physical_address_limit = phys_end;
+                }
+                usable_memory += header.bootinfo.memory_map[bii].size;
+                while (phys < phys_end)
+                {
+                    bool is_reserved = false;
+                    for (size_t ri = 0u; ri < reserved.length; ri++)
+                    {
+                        if ((reserved[ri][0] <= phys) && (phys < reserved[ri][1]))
+                        {
+                            is_reserved = true;
+                            break;
+                        }
+                    }
+                    if (!is_reserved)
+                    {
+                        Hippo.free_page(phys);
+                    }
+                    phys += PAGE_SIZE;
+                }
+            }
+        }
+
+        /*
+         * Now that we have available physical pages to allocate from, we can
+         * build new page tables to replace the bootloader page tables.
+         */
+        build_page_tables(header, physical_address_limit);
+
+        /*
+         * After we have switched to the newly constructed page tables, we can
+         * iterate through and free the bootloader page tables. They are most
+         * likely already mapped because we just identity mapped every page up
+         * to the physical_address_limit determined above. But just in case the
+         * bootloader used the last pages of RAM for the page table pages, we
+         * will make sure to map them as we traverse them.
+         */
+        size_t reclaimed_bootloader_page_table_memory = reclaim_bootloader_page_table_pages(bootloader_pt_base) << 10u;
+        usable_memory += reclaimed_bootloader_page_table_memory;
+
+        usable_memory += LinkerAddresses.hulk_bss_size;
+        usable_memory += header.stack_size;
+        usable_memory += fb_size;
+        Klog.writefln("Usable memory: %uKB", usable_memory >> 10u);
+        Klog.writefln("Kernel size: %uKB", (LinkerAddresses.hulk_binary_size + LinkerAddresses.hulk_bss_size + header.stack_size) >> 10u);
+    }
+
+    public static void map(ulong virtual, ulong physical, ulong flags)
+    {
+        PageTable * pt = m_pt_base;
+        for (size_t level = 0; level < 4u; level++)
+        {
+            PageTableEntry * ppte = pt.entry(virtual, level);
+            if (level < 3u)
+            {
+                PageTableEntry pte = *ppte;
+                if (pte.present)
+                {
+                    pt = pte.follow();
+                }
+                else
+                {
+                    PageTable * next_pt = allocate_pt();
+                    *ppte = PageTableEntry(next_pt, PT_WRITABLE | PT_PRESENT);
+                    pt = next_pt;
+                }
+            }
+            else
+            {
+                *ppte = PageTableEntry(cast(ulong)physical, flags | PT_PRESENT);
+            }
+        }
+    }
+
+    public static void map(T, U)(T virtual, U physical, ulong flags)
+    {
+        map(cast(ulong)virtual, cast(ulong)physical, flags);
+    }
+
+    public static void map_range(ulong virtual, ulong physical, size_t length, ulong flags)
+    {
+        size_t end = virtual + length;
+        while (virtual < end)
+        {
+            map(virtual, physical, flags);
+            virtual += PAGE_SIZE;
+            physical += PAGE_SIZE;
+        }
+    }
+
+    public static void map_range(T, U)(T virtual, U physical, size_t length, ulong flags)
+    {
+        map_range(cast(ulong)virtual, cast(ulong)physical, length, flags);
+    }
+
+    public static void identity_map_range(ulong address, size_t length, ulong flags)
+    {
+        size_t end = address + length;
+        for (size_t page = address & 0xFFFF_FFFF_FFFF_F000u; page < end; page += PAGE_SIZE)
+        {
+            map(page, page, flags);
+        }
+    }
+
+    public static void identity_map_range(T)(T address, size_t length, ulong flags)
+    {
+        identity_map_range(cast(ulong)address, length, flags);
+    }
+
+    public static void debug_lookup(void * address)
+    {
+        Klog.writefln("Debugging page table lookup of 0x%x", address);
+        PageTable * pt = m_pt_base;
+        for (size_t level = 0; level < 4u; level++)
+        {
+            PageTableEntry pte = *pt.entry(address, level);
+            Klog.writefln("Level %u, index %u, entry = 0x%x", level, pt.index(address, level), pte);
+            if (pte.present)
+            {
+                pt = pte.follow();
+            }
+            else
+            {
+                break;
+            }
+            if (pte.huge)
+            {
+                break;
+            }
+        }
+    }
+
+    private static PageTable * allocate_pt()
+    {
+        PageTable * pt = cast(PageTable *)Hippo.allocate_page();
+        memset64(pt, 0u, PAGE_SIZE / 8u);
+        return pt;
+    }
+}

src/hulk/hurl/package.d

@@ -0,0 +1,3 @@
+module hulk.hurl;
+
+public import hulk.hurl.hurl;

src/hulk/idt.d

@@ -0,0 +1,133 @@
+/**
+ * IDT (Interrupt Descriptor Table) functionality.
+ */
+module hulk.idt;
+
+import hulk.gdt;
+import ldc.llvmasm;
+import hulk.fb;
+import hulk.console;
+import hulk.klog;
+import hulk.apic;
+
+struct Idt
+{
+    /* The I/O APIC is configured to map IRQ 0 to interrupt 64 (0x40). */
+    public static enum ulong INT_APIC_BASE = 0x40u; /* IRQ 0 */
+    public static enum ulong INT_APIC_COUNT = 24u;
+
+    public static enum ulong INT_APIC_TIMER = 0x70u;
+    public static enum ulong INT_APIC_LINT0 = 0x71u;
+    public static enum ulong INT_APIC_LINT1 = 0x72u;
+    public static enum ulong INT_APIC_SPURIOUS = 0xFFu;
+
+    struct idtr_t
+    {
+        ushort limit;
+        align(2) ulong offset;
+    }
+    static assert(idtr_t.sizeof == 10u);
+
+    alias descriptor_t = ulong[2];
+
+    static __gshared align(0x10) descriptor_t[256] idt;
+    static assert(idt.sizeof == (256u * 16u));
+    static __gshared idtr_t idtr;
+
+    public static void initialize()
+    {
+        set_isrs();
+        idtr.limit = idt.sizeof - 1u;
+        idtr.offset = cast(ulong)&idt;
+        lidt(&idtr);
+    }
+
+    private static void lidt(idtr_t * idtr)
+    {
+        __asm("lidt $0", "*m", idtr);
+    }
+
+    private static bool isr_has_error_code(size_t isr)
+    {
+        return (isr == 8) ||
+            ((10 <= isr) && (isr <= 14)) ||
+            (isr == 17) ||
+            (isr == 21) ||
+            (isr == 29) ||
+            (isr == 30);
+    }
+
+    private static bool isr_is_trap(size_t isr)
+    {
+        return (isr < 32u) && (isr != 2u);
+    }
+
+    private static void set_isrs()
+    {
+        ulong isr_address;
+        static foreach(isr; 0 .. 256)
+        {
+            mixin("isr_address = __asm!ulong(`
+                movabs $$1f, %rax
+                jmp 2f
+                1:
+                pushq %rdi
+                pushq %rsi
+                pushq %rax
+                mov $$", isr, ", %rdi
+                " ~ (isr_has_error_code(isr) ? "mov 0x18(%rsp), %rsi" : "") ~ "
+                movabs $$isr, %rax
+                callq *%rax
+                popq %rax
+                popq %rsi
+                popq %rdi
+                " ~ (isr_has_error_code(isr) ? "add $$8, %rsp" : "") ~ "
+                iretq
+                2:`, `={rax}`);");
+            mixin("set_descriptor(", isr, ", 0u, " ~
+                    (isr_is_trap(isr) ? "true" : "false") ~ ", isr_address);");
+        }
+    }
+
+    private static void set_descriptor(size_t index, ulong dpl, bool trap, ulong offset)
+    {
+        idt[index][0] =
+            0x0000_8E_00_0000_0000u |
+            ((offset & 0xFFFF_0000u) << 32u) |
+            (dpl << 45u) |
+            ((trap ? 1uL : 0uL) << 40u) |
+            (Gdt.SELECTOR_KERNEL_CODE << 16u) |
+            (offset & 0xFFFFu);
+        idt[index][1] = offset >> 32u;
+    }
+}
+
+public extern(C) void isr(ulong vector, ulong arg)
+{
+    if ((vector >= Idt.INT_APIC_BASE) && (vector < (Idt.INT_APIC_BASE + Idt.INT_APIC_COUNT)))
+    {
+        Apic.isr(vector);
+    }
+    else
+    {
+        switch (vector)
+        {
+        case Idt.INT_APIC_TIMER:
+        case Idt.INT_APIC_LINT0:
+        case Idt.INT_APIC_LINT1:
+        case Idt.INT_APIC_SPURIOUS:
+            Apic.isr(vector);
+            break;
+
+        default:
+            Console.clear();
+            Fb.clear(0xFF8000u);
+            Klog.writefln("ISR %u, 0x%x", vector, arg);
+            __asm("cli", "");
+            for (;;)
+            {
+                __asm("hlt", "");
+            }
+        }
+    }
+}

src/hulk/klog.d

@@ -0,0 +1,73 @@
+/**
+ * HULK Kernel Log buffer.
+ */
+module hulk.klog;
+
+import core.stdc.stdarg;
+import hulk.console;
+static import hulk.writef;
+
+struct Klog
+{
+    /**
+     * Kernel buffer size log.
+     * 16 gives a kernel buffer size of 64KB.
+     */
+    private enum size_t KLOG_SIZE_LOG = 16u;
+
+    /** Kernel buffer size.  */
+    private enum size_t KLOG_SIZE = 1u << KLOG_SIZE_LOG;
+
+    /** Kernel log buffer. */
+    private static __gshared align(4096) ubyte[KLOG_SIZE] klog_buffer;
+
+    /** Write index in the kernel log buffer. */
+    private static __gshared size_t klog_index;
+
+    /**
+     * Initialize the klog module.
+     */
+    public static void initialize()
+    {
+    }
+
+    /**
+     * Write a formatted string to the kernel log.
+     *
+     * @param s Format string.
+     * @param args Variable arguments structure.
+     */
+    public static void writef(string s, va_list args)
+    {
+        hulk.writef.writef(s, args, function void(ubyte ch) {
+                    Console.write(ch);
+                });
+    }
+
+    /**
+     * Write a formatted string to the kernel log.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writef(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        va_end(args);
+    }
+
+    /**
+     * Write a formatted string and newline to the kernel log.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writefln(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        writef("\n", args);
+        va_end(args);
+    }
+}

src/hulk/linker_addresses.d

@@ -0,0 +1,139 @@
+/**
+ * This module provides access to linker-defined symbols.
+ */
+module hulk.linker_addresses;
+
+private extern extern(C) __gshared ubyte _hulk_header_start;
+private extern extern(C) __gshared ubyte _hulk_header_end;
+private extern extern(C) __gshared ubyte _hulk_header_size;
+
+private extern extern(C) __gshared ubyte _hulk_text_start;
+private extern extern(C) __gshared ubyte _hulk_text_end;
+private extern extern(C) __gshared ubyte _hulk_text_size;
+
+private extern extern(C) __gshared ubyte _hulk_rodata_start;
+private extern extern(C) __gshared ubyte _hulk_rodata_end;
+private extern extern(C) __gshared ubyte _hulk_rodata_size;
+
+private extern extern(C) __gshared ubyte _hulk_data_start;
+private extern extern(C) __gshared ubyte _hulk_data_end;
+private extern extern(C) __gshared ubyte _hulk_data_size;
+
+private extern extern(C) __gshared ubyte _hulk_bss_start;
+private extern extern(C) __gshared ubyte _hulk_bss_end;
+private extern extern(C) __gshared ubyte _hulk_bss_size;
+
+/* hulk_binary includes header, text, rodata, and data */
+private extern extern(C) __gshared ubyte _hulk_binary_size;
+
+/* hulk_mem includes header, text, rodata, data, and bss */
+private extern extern(C) __gshared ubyte _hulk_mem_start;
+private extern extern(C) __gshared ubyte _hulk_mem_end;
+private extern extern(C) __gshared ubyte _hulk_mem_size;
+
+/**
+ * This struct provides access to linker-defined symbols.
+ */
+public struct LinkerAddresses
+{
+    public static @property ulong hulk_header_start()
+    {
+        return cast(ulong)&_hulk_header_start;
+    }
+
+    public static @property ulong hulk_header_end()
+    {
+        return cast(ulong)&_hulk_header_end;
+    }
+
+    public static @property ulong hulk_header_size()
+    {
+        return cast(ulong)&_hulk_header_size;
+    }
+
+
+    public static @property ulong hulk_text_start()
+    {
+        return cast(ulong)&_hulk_text_start;
+    }
+
+    public static @property ulong hulk_text_end()
+    {
+        return cast(ulong)&_hulk_text_end;
+    }
+
+    public static @property ulong hulk_text_size()
+    {
+        return cast(ulong)&_hulk_text_size;
+    }
+
+
+    public static @property ulong hulk_rodata_start()
+    {
+        return cast(ulong)&_hulk_rodata_start;
+    }
+
+    public static @property ulong hulk_rodata_end()
+    {
+        return cast(ulong)&_hulk_rodata_end;
+    }
+
+    public static @property ulong hulk_rodata_size()
+    {
+        return cast(ulong)&_hulk_rodata_size;
+    }
+
+
+    public static @property ulong hulk_data_start()
+    {
+        return cast(ulong)&_hulk_data_start;
+    }
+
+    public static @property ulong hulk_data_end()
+    {
+        return cast(ulong)&_hulk_data_end;
+    }
+
+    public static @property ulong hulk_data_size()
+    {
+        return cast(ulong)&_hulk_data_size;
+    }
+
+
+    public static @property ulong hulk_bss_start()
+    {
+        return cast(ulong)&_hulk_bss_start;
+    }
+
+    public static @property ulong hulk_bss_end()
+    {
+        return cast(ulong)&_hulk_bss_end;
+    }
+
+    public static @property ulong hulk_bss_size()
+    {
+        return cast(ulong)&_hulk_bss_size;
+    }
+
+
+    public static @property ulong hulk_binary_size()
+    {
+        return cast(ulong)&_hulk_binary_size;
+    }
+
+
+    public static @property ulong hulk_mem_start()
+    {
+        return cast(ulong)&_hulk_mem_start;
+    }
+
+    public static @property ulong hulk_mem_end()
+    {
+        return cast(ulong)&_hulk_mem_end;
+    }
+
+    public static @property ulong hulk_mem_size()
+    {
+        return cast(ulong)&_hulk_mem_size;
+    }
+}

src/hulk/memory.d

@@ -0,0 +1,62 @@
+/**
+ * Memory-related functions.
+ */
+module hulk.memory;
+
+import ldc.llvmasm;
+
+void memset(void * dest, ubyte v, size_t n)
+{
+    __asm("rep stosb",
+          "{al},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset16(void * dest, ushort v, size_t n)
+{
+    __asm("rep stosw",
+          "{ax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset32(void * dest, uint v, size_t n)
+{
+    __asm("rep stosl",
+          "{eax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memset64(void * dest, ulong v, size_t n)
+{
+    __asm("rep stosq",
+          "{rax},{rcx},{rdi},~{rcx},~{rdi},~{memory}",
+          v, n, dest);
+}
+
+void memcpy(void * dest, const(void) * src, size_t n)
+{
+    __asm("rep movsb",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy16(void * dest, const(void) * src, size_t n)
+{
+    __asm("rep movsw",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy32(void * dest, const(void) * src, size_t n)
+{
+    __asm("rep movsl",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}
+
+void memcpy64(void * dest, const(void) * src, size_t n)
+{
+    __asm("rep movsq",
+          "{rcx},{rsi},{rdi},~{rcx},~{rsi},~{rdi},~{memory}",
+          n, src, dest);
+}

src/hulk/mtrr.d

@@ -0,0 +1,70 @@
+/**
+ * MTRR (Memory Type Range Register) support for HULK.
+ */
+module hulk.mtrr;
+
+import hulk.cpu;
+import hulk.klog;
+
+enum ulong MTRR_TYPE_UC = 0u; /* Uncacheable */
+enum ulong MTRR_TYPE_WC = 1u; /* Write-Combining */
+enum ulong MTRR_TYPE_WT = 4u; /* Writethrough */
+enum ulong MTRR_TYPE_WP = 5u; /* Write-Protect */
+enum ulong MTRR_TYPE_WB = 6u; /* Writeback */
+
+enum uint MSR_MTRRCAP = 0xFEu;
+enum uint MSR_MTRRDEFTYPE = 0x2FFu;
+enum uint MSR_MTRRPHYSBASE0 = 0x200u;
+enum uint MSR_MTRRPHYSMASK0 = 0x201u;
+
+enum ulong MTRRCAP_WC = 0x400u;
+enum ulong MTRRCAP_FIX = 0x100u;
+enum ulong MTRRCAP_VCNT_MASK = 0xFFu;
+
+enum ulong MTRRDEFTYPE_E = 0x800u;
+enum ulong MTRRDEFTYPE_FE = 0x400u;
+enum ulong MTRRDEFTYPE_TYPE_MASK = 0xFFu;
+
+enum ulong MTRRPHYSBASE_PHYSBASE_MASK = 0x000F_FFFF_FFFF_F000u;
+enum ulong MTRRPHYSBASE_TYPE_MASK = 0xFFu;
+
+enum ulong MTRRPHYSMASK_PHYSMASK_MASK = 0x000F_FFFF_FFFF_F000u;
+enum ulong MTRRPHYSMASK_VALID = 0x800u;
+
+struct Mtrr
+{
+    public static void initialize()
+    {
+        uint ebx;
+        uint ecx;
+        uint edx;
+        cpuid1(&ebx, &ecx, &edx);
+        if ((edx & CPUID_1_EDX_MTRR) == 0u)
+        {
+            Klog.writefln("CPU does not support MTRR");
+            return;
+        }
+        const(ulong) mtrrcap = rdmsr(MSR_MTRRCAP);
+        const(ulong) mtrrdeftype = rdmsr(MSR_MTRRDEFTYPE);
+    }
+
+    private static ulong get_phys_base(uint n)
+    {
+        return rdmsr(MSR_MTRRPHYSBASE0 + 2u * n);
+    }
+
+    private static void set_phys_base(uint n, ulong physbase)
+    {
+        wrmsr(MSR_MTRRPHYSBASE0 + 2u * n, physbase);
+    }
+
+    private static ulong get_phys_mask(uint n)
+    {
+        return rdmsr(MSR_MTRRPHYSMASK0 + 2u * n);
+    }
+
+    private static void set_phys_mask(uint n, ulong physmask)
+    {
+        wrmsr(MSR_MTRRPHYSMASK0 + 2u * n, physmask);
+    }
+}

src/hulk/pagetable.d

@@ -0,0 +1,193 @@
+/**
+ * Page table structures.
+ */
+module hulk.pagetable;
+
+/** Page table entry attributes. @{ */
+enum ulong PT_PRESENT = 0x1u;
+enum ulong PT_WRITABLE = 0x2u;
+enum ulong PT_USER = 0x4u;
+enum ulong PT_WRITE_THROUGH = 0x8u;
+enum ulong PT_DISABLE_CACHE = 0x10u;
+enum ulong PT_ACCESSED = 0x20u;
+enum ulong PT_DIRTY = 0x40u;
+enum ulong PT_HUGE_PAGE = 0x80u;
+enum ulong PT_GLOBAL = 0x100u;
+enum ulong PT_NO_EXECUTE = 0x8000_0000_0000_0000u;
+/** @} */
+
+/** Page size in bytes. */
+enum ulong PAGE_SIZE = 4096u;
+
+/**
+ * Structure that represents a page table entry.
+ */
+struct PageTableEntry
+{
+    /** The raw page table entry is a 64-bit ulong. */
+    public ulong entry;
+    alias entry this;
+
+    /**
+     * Construct a page table entry.
+     *
+     * @param address
+     *   Address pointed to by the page table entry (ulong or pointer).
+     * @param flags
+     *   Page table flags (ORed set of PT_*).
+     */
+    this(T)(T address, ulong flags = 0u)
+    {
+        entry = cast(ulong)address | flags;
+    }
+
+    /**
+     * Return whether the page is present.
+     */
+    public @property bool present() const
+    {
+        return (entry & PT_PRESENT) != 0u;
+    }
+
+    /**
+     * Return whether the page is writable.
+     */
+    public @property bool writable() const
+    {
+        return (entry & PT_WRITABLE) != 0u;
+    }
+
+    /**
+     * Return whether the page is a user page.
+     */
+    public @property bool user() const
+    {
+        return (entry & PT_USER) != 0u;
+    }
+
+    /**
+     * Return whether the page is write-through.
+     */
+    public @property bool write_through() const
+    {
+        return (entry & PT_WRITE_THROUGH) != 0u;
+    }
+
+    /**
+     * Return whether the page has disable cache set.
+     */
+    public @property bool disable_cache() const
+    {
+        return (entry & PT_DISABLE_CACHE) != 0u;
+    }
+
+    /**
+     * Return whether the page is huge.
+     */
+    public @property bool huge() const
+    {
+        return (entry & PT_HUGE_PAGE) != 0u;
+    }
+
+    /**
+     * Return whether the page is global.
+     */
+    public @property bool global() const
+    {
+        return (entry & PT_GLOBAL) != 0u;
+    }
+
+    /**
+     * Return whether the page is no-execute.
+     */
+    public @property bool no_execute() const
+    {
+        return (entry & PT_NO_EXECUTE) != 0u;
+    }
+
+    /**
+     * Return whether the page is dirty.
+     */
+    public @property bool dirty() const
+    {
+        return (entry & PT_DIRTY) != 0u;
+    }
+
+    /**
+     * Return whether the page is accessed.
+     */
+    public @property bool accessed() const
+    {
+        return (entry & PT_ACCESSED) != 0u;
+    }
+
+    /**
+     * Follow the page table entry to the next page table it points to.
+     */
+    public PageTable * follow() const
+    {
+        return cast(PageTable *)(entry & 0x7FFF_FFFF_FFFF_F000u);
+    }
+}
+static assert(PageTableEntry.sizeof == 8u);
+
+/**
+ * Structure that represents a page table.
+ */
+struct PageTable
+{
+    /** Number of page table entries in a page table. */
+    enum size_t N_ENTRIES = 512u;
+
+    /** Page table entries. */
+    private PageTableEntry[N_ENTRIES] entries;
+
+    /**
+     * Access the PageTableEntry for the given address and page table level.
+     *
+     * @param address
+     *   Address to look up the page table entry (ulong or pointer).
+     * @param level
+     *   Page table level (0-4).
+     */
+    public PageTableEntry * entry(T)(T address, ulong level)
+    {
+        return &entries[index(cast(ulong)address, level)];
+    }
+
+    /**
+     * Determine the index into the page table for the given address and page
+     * table level.
+     *
+     * @param address
+     *   Address to look up the page table entry (ulong or pointer).
+     * @param level
+     *   Page table level (0-4).
+     */
+    public ulong index(T)(T address, ulong level)
+    {
+        return (cast(ulong)address >> (39u - (9u * level))) & 0x1FFu;
+    }
+
+    /**
+     * Access a page table entry by linear index.
+     *
+     * @param index
+     *   Page table index (0-511).
+     *
+     * @return PageTableEntry at the given index.
+     */
+    public PageTableEntry opIndex(size_t index)
+    {
+        return entries[index];
+    }
+}
+static assert(PageTable.sizeof == 4096u);
+
+/**
+ * Get the base address of the page containing the given address.
+ */
+T page_address(T)(T address)
+{
+    return cast(T)(cast(ulong)address & ~(PAGE_SIZE - 1u));
+}

src/hulk/pci.d

@@ -0,0 +1,230 @@
+module hulk.pci;
+
+import hulk.cpu;
+import hulk.klog;
+import hulk.hurl;
+import hulk.hurl.a1;
+import hulk.range;
+import hulk.usb.xhci;
+
+struct Pci
+{
+    /* IO address for PCI configuration address. */
+    enum IO_ADDR_CONFIG_ADDRESS = 0xCF8u;
+
+    /* IO address for PCI configuration data. */
+    enum IO_ADDR_CONFIG_DATA = 0xCFCu;
+
+    struct Address
+    {
+        /** Bus number (0-255). */
+        ubyte bus_nr;
+
+        /** Device number (0-31). */
+        ubyte device_nr;
+
+        /** Function number (0-7). */
+        ubyte function_nr;
+    }
+
+    struct Device
+    {
+        Address address;
+        ushort vendor_id;
+        ushort device_id;
+        ubyte class_id;
+        ubyte subclass_id;
+        ubyte if_id;
+        bool multifunction;
+        ubyte header_type;
+        Range[6] memory_ranges;
+
+        void initialize(Address address, ushort vendor_id, ushort device_id)
+        {
+            this.address = address;
+            this.vendor_id = vendor_id;
+            this.device_id = device_id;
+            uint reg2 = read_config_register(address, 2u);
+            class_id = (reg2 >> 24u) & 0xFFu;
+            subclass_id = (reg2 >> 16u) & 0xFFu;
+            if_id = (reg2 >> 8u) & 0xFFu;
+            Klog.writefln("Found PCI device %04x:%04x (%02x:%02x:%02x) at %02u:%02u.%u",
+                    vendor_id, device_id,
+                    class_id, subclass_id, if_id,
+                    address.bus_nr, address.device_nr, address.function_nr);
+            uint reg3 = read_config_register(address, 3u);
+            header_type = (reg3 >> 16u) & 0x7Fu;
+            multifunction = (address.function_nr == 0u) && ((reg3 & (1u << 23u)) != 0u);
+
+            if (header_type == 0u)
+            {
+                map_memory_regions();
+            }
+
+            spawn_device_instance();
+        }
+
+        private void map_memory_regions()
+        {
+            size_t range_index;
+            uint[2] r;
+            uint[2] s;
+            for (uint reg_no = 4u; reg_no <= 9u; reg_no++)
+            {
+                /* Read the BAR. */
+                r[0] = read_config_register(address, reg_no);
+                /* Skip zeroed BARs. */
+                if (r[0] == 0u)
+                {
+                    continue;
+                }
+                /* Skip I/O BARs. */
+                if ((r[0] & 1u) != 0u)
+                {
+                    continue;
+                }
+                bool is_64bit;
+                uint bar_type = (r[0] >> 1u) & 0x3u;
+                if (bar_type == 0u)
+                {
+                    /* 32-bit region. */
+                    r[1] = 0u;
+                }
+                else if ((bar_type == 2u) && (reg_no < 9u))
+                {
+                    /* 64-bit region. */
+                    is_64bit = true;
+                    r[1] = read_config_register(address, reg_no + 1);
+                }
+                else
+                {
+                    continue;
+                }
+
+                /* Determine the region length. */
+                write_config_register(address, reg_no, 0xFFFF_FFFFu);
+                s[0] = read_config_register(address, reg_no);
+                write_config_register(address, reg_no, r[0]);
+                if (is_64bit)
+                {
+                    write_config_register(address, reg_no + 1, 0xFFFF_FFFFu);
+                    s[1] = read_config_register(address, reg_no + 1);
+                    write_config_register(address, reg_no + 1, r[1]);
+                }
+                else
+                {
+                    s[1] = 0xFFFF_FFFFu;
+                }
+                ulong mm_region_address = (cast(ulong)r[0] & 0xFFFF_FFF0u) | (cast(ulong)r[1] << 32u);
+                ulong length = ~((cast(ulong)s[0] & 0xFFFF_FFF0u) | (cast(ulong)s[1] << 32u)) + 1u;
+                ulong flags = (r[0] & 0x8) != 0u ? PT_WRITE_THROUGH : 0u;
+                Hurl.identity_map_range(mm_region_address, length, flags);
+                memory_ranges[range_index].address = mm_region_address;
+                memory_ranges[range_index].length = length;
+                range_index++;
+                if (is_64bit)
+                {
+                    reg_no++;
+                }
+            }
+        }
+
+        private void spawn_device_instance()
+        {
+            switch (class_id)
+            {
+            case SerialBusController.ID:
+                switch (subclass_id)
+                {
+                case SerialBusController.USBController.ID:
+                    switch (if_id)
+                    {
+                    case SerialBusController.USBController.XHCIController.ID:
+                        XHCI.build(&this);
+                        break;
+
+                    default:
+                        break;
+                    }
+                    break;
+
+                default:
+                    break;
+                }
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+
+    struct SerialBusController
+    {
+        enum ID = 0x0Cu;
+
+        struct USBController
+        {
+            enum ID = 0x03u;
+
+            struct XHCIController
+            {
+                enum ID = 0x30u;
+            }
+        }
+    }
+
+    private static uint read_config_register(Address address, uint register_id)
+    {
+        uint cfg_addr = 0x8000_0000u |
+            (address.bus_nr << 16u) |
+            (address.device_nr << 11u) |
+            (address.function_nr << 8u) |
+            (register_id << 2u);
+        out32(IO_ADDR_CONFIG_ADDRESS, cfg_addr);
+        return in32(IO_ADDR_CONFIG_DATA);
+    }
+
+    private static void write_config_register(Address address, uint register_id, uint value)
+    {
+        uint cfg_addr = 0x8000_0000u |
+            (address.bus_nr << 16u) |
+            (address.device_nr << 11u) |
+            (address.function_nr << 8u) |
+            (register_id << 2u);
+        out32(IO_ADDR_CONFIG_ADDRESS, cfg_addr);
+        out32(IO_ADDR_CONFIG_DATA, value);
+    }
+
+    private static void scan(Address address)
+    {
+        ulong reg0 = read_config_register(address, 0u);
+        if (reg0 != 0xFFFFFFFFu)
+        {
+            ushort vendor_id = reg0 & 0xFFFFu;
+            ushort device_id = (reg0 >> 16u) & 0xFFFFu;
+            Device * device = A1.allocate!Device();
+            device.initialize(address, vendor_id, device_id);
+            if (device.multifunction)
+            {
+                for (address.function_nr = 1u; address.function_nr < 8u; address.function_nr++)
+                {
+                    scan(address);
+                }
+            }
+        }
+    }
+
+    public static void initialize()
+    {
+        Klog.writefln("Scanning PCI devices...");
+        for (uint bus_nr = 0u; bus_nr < 256u; bus_nr++)
+        {
+            for (ubyte device_nr = 0u; device_nr < 32u; device_nr++)
+            {
+                scan(Address(cast(ubyte)bus_nr, device_nr, 0u));
+            }
+        }
+        Klog.writefln("PCI scan complete.");
+    }
+}

src/hulk/pic.d

@@ -0,0 +1,16 @@
+/**
+ * PIC (Programmable Interrupt Controller) functionality.
+ */
+module hulk.pic;
+
+import hulk.cpu;
+
+struct Pic
+{
+    public static void initialize()
+    {
+        /* Disable the PIC. */
+        out8(0xA1u, 0xFFu);
+        out8(0x21u, 0xFFu);
+    }
+}

src/hulk/pit.d

@@ -0,0 +1,42 @@
+/**
+ * PIT (Programmable Interval Timer) functionality.
+ */
+module hulk.pit;
+
+import hulk.cpu;
+import hulk.klog;
+
+struct Pit
+{
+    /** PIT input frequency in 1/1000 Hz. */
+    private enum ulong PIT_FREQUENCY_1000HZ = 1_193_181_667u;
+    private enum ulong TARGET_INTERRUPT_HZ = 100u;
+    private enum ulong TARGET_INTERRUPT_1000HZ = TARGET_INTERRUPT_HZ * 1000u;
+    private enum ulong PIT_DIVIDER = (PIT_FREQUENCY_1000HZ + TARGET_INTERRUPT_1000HZ / 2u) / TARGET_INTERRUPT_1000HZ;
+
+    /** PIT channel 0 I/O port. */
+    private enum ubyte PORT_CH_0 = 0x40u;
+    /** PIT channel 1 I/O port. */
+    private enum ubyte PORT_CH_1 = 0x41u;
+    /** PIT channel 2 I/O port. */
+    private enum ubyte PORT_CH_2 = 0x42u;
+    /** PIT mode/command register I/O port. */
+    private enum ubyte PORT_MC = 0x43u;
+
+    private enum ubyte MC_CH_0 = 0x00u;
+    private enum ubyte MC_LO_HI = 0x30u;
+    private enum ubyte MC_RATE_GENERATOR = 0x04u;
+    private enum ubyte MC_BINARY = 0x00u;
+
+    public static void initialize()
+    {
+        out8(PORT_MC, MC_CH_0 | MC_LO_HI | MC_RATE_GENERATOR | MC_BINARY);
+        out8(PORT_CH_0, PIT_DIVIDER & 0xFFu);
+        out8(PORT_CH_0, PIT_DIVIDER >> 8u);
+    }
+
+    public static void isr()
+    {
+        Klog.writefln("PIT ISR");
+    }
+}

src/hulk/range.d

@@ -0,0 +1,27 @@
+module hulk.range;
+
+/**
+ * Representation of a memory range.
+ */
+struct Range
+{
+    /** Range base address. */
+    void * _address;
+
+    /** Range length. */
+    size_t length;
+
+    /** Set the range address. */
+    @property void * address(T)(T a)
+    {
+        static assert(T.sizeof == size_t.sizeof);
+        _address = cast(void *)a;
+        return _address;
+    }
+
+    /** Get the range address. */
+    @property void * address()
+    {
+        return _address;
+    }
+}

src/hulk/rtc.d

@@ -0,0 +1,149 @@
+/**
+ * RTC (Real-Time Clock) functionality.
+ */
+module hulk.rtc;
+
+import hulk.cpu;
+import hulk.klog;
+
+struct Rtc
+{
+    private enum ubyte PORT_SELECT = 0x70u;
+    private enum ubyte PORT_DATA = 0x71u;
+
+    private enum ubyte DISABLE_NMI = 0x80u;
+
+    private enum ubyte REG_RTC_SECONDS = 0x0u;
+    private enum ubyte REG_RTC_MINUTES = 0x2u;
+    private enum ubyte REG_RTC_HOURS = 0x4u;
+    private enum ubyte REG_RTC_DAY = 0x7u;
+    private enum ubyte REG_RTC_MONTH = 0x8u;
+    private enum ubyte REG_RTC_YEAR = 0x9u;
+    private enum ubyte REG_SR_A = 0xAu;
+    private enum ubyte REG_SR_B = 0xBu;
+    private enum ubyte REG_SR_C = 0xCu;
+
+    private enum ubyte SR_A_RTC_UPDATE_IN_PROGRESS = 0x80u;
+    private enum ubyte SR_B_24HOUR = 0x02u;
+    private enum ubyte SR_B_BINARY = 0x04u;
+    private enum ubyte SR_B_ENABLE_IRQ = 0x40u;
+
+    private static __gshared bool rtc_24hour_mode;
+    private static __gshared bool rtc_binary_mode;
+
+    static struct time
+    {
+        public ubyte year;
+        public ubyte month;
+        public ubyte day;
+        public ubyte hour;
+        public ubyte minute;
+        public ubyte second;
+    }
+
+    public static void initialize()
+    {
+        /* Enable IRQ 8 to receive RTC interrupts. */
+        ubyte sr_b = read_register(REG_SR_B, true);
+        write_register(REG_SR_B, sr_b | SR_B_ENABLE_IRQ, true);
+
+        /* Record RTC mode flags from status register B. */
+        rtc_24hour_mode = (sr_b & SR_B_24HOUR) != 0u;
+        rtc_binary_mode = (sr_b & SR_B_BINARY) != 0u;
+
+        /* Read the current system time. */
+        time t = read_rtc_time();
+        Klog.writefln("System time is 20%02u-%02u-%02u %02u:%02u:%02u",
+                t.year, t.month, t.day, t.hour, t.minute, t.second);
+
+        /* Send EOI to enable more RTC interrupts and re-enable NMIs. */
+        eoi();
+    }
+
+    private static ubyte read_register(ubyte register, bool disable_nmi = false)
+    {
+        out8(PORT_SELECT, register | (disable_nmi ? DISABLE_NMI : 0u));
+        return in8(PORT_DATA);
+    }
+
+    private static void write_register(ubyte register, ubyte value, bool disable_nmi = false)
+    {
+        out8(PORT_SELECT, register | (disable_nmi ? DISABLE_NMI : 0u));
+        out8(PORT_DATA, value);
+    }
+
+    private static void eoi()
+    {
+        /* Read from status register C to clear the interrupt. */
+        read_register(REG_SR_C);
+    }
+
+    public static void isr()
+    {
+        static __gshared ulong count;
+        static __gshared ulong seconds;
+        count++;
+        if ((count % 1024) == 0u)
+        {
+            seconds++;
+        }
+        eoi();
+    }
+
+    private static time read_rtc_time()
+    {
+        time[2] times;
+        size_t reads;
+        do
+        {
+            times[reads & 1] = read_rtc_time_unsafe();
+            reads++;
+        } while ((reads < 2u) || (times[0] != times[1]));
+        return times[0];
+    }
+
+    private static time read_rtc_time_unsafe()
+    {
+        time t;
+        while ((read_register(REG_SR_A) & SR_A_RTC_UPDATE_IN_PROGRESS) != 0u)
+        {
+        }
+        t.year = read_rtc_time_register(REG_RTC_YEAR);
+        t.month = read_rtc_time_register(REG_RTC_MONTH);
+        t.day = read_rtc_time_register(REG_RTC_DAY);
+        t.minute = read_rtc_time_register(REG_RTC_MINUTES);
+        t.second = read_rtc_time_register(REG_RTC_SECONDS);
+        /* Hour field is treated differently because it might have 'PM' flag
+         * in highest bit if we're in 24-hour mode. */
+        ubyte hour = read_register(REG_RTC_HOURS);
+        ubyte pm = hour >> 7u;
+        hour &= 0x7Fu;
+        if (!rtc_binary_mode)
+        {
+            /* Hour is in BCD format; convert to binary. */
+            hour = bcd_to_binary(hour);
+        }
+        if (!rtc_24hour_mode)
+        {
+            /* Hour is in 12-hour format; convert to 24-hour format. */
+            hour = cast(ubyte)((hour % 12u) + pm * 12u);
+        }
+        t.hour = hour;
+        return t;
+    }
+
+    private static ubyte read_rtc_time_register(ubyte register)
+    {
+        ubyte value = read_register(register);
+        if (!rtc_binary_mode)
+        {
+            value = bcd_to_binary(value);
+        }
+        return value;
+    }
+
+    private static ubyte bcd_to_binary(ubyte bcd)
+    {
+        return (bcd & 0xFu) + ((bcd & 0xF0u) >> 4u) * 10u;
+    }
+}

src/hulk/serial.d

@@ -0,0 +1,74 @@
+/**
+ * Serial port access.
+ */
+module hulk.serial;
+
+import hulk.cpu;
+import core.stdc.stdarg;
+static import hulk.writef;
+
+struct Serial
+{
+    enum BASE_PORT = 0x3F8;
+
+    /**
+     * Initialize the serial module.
+     */
+    static void initialize()
+    {
+    }
+
+    /**
+     * Write a character to the serial port.
+     *
+     * @param ch Character to write.
+     */
+    static void write(ubyte ch)
+    {
+        if (ch == '\n')
+        {
+            out8(BASE_PORT, '\r');
+        }
+        out8(BASE_PORT, ch);
+    }
+
+    /**
+     * Write a formatted string to the serial port.
+     *
+     * @param s Format string.
+     * @param args Variable arguments structure.
+     */
+    public static void writef(string s, va_list args)
+    {
+        hulk.writef.writef(s, args, function void(ubyte ch) {
+                    Serial.write(ch);
+                });
+    }
+
+    /**
+     * Write a formatted string to the serial port.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writef(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        va_end(args);
+    }
+
+    /**
+     * Write a formatted string and newline to the serial port.
+     *
+     * @param s Format string.
+     */
+    public static extern (C) void writefln(string s, ...)
+    {
+        va_list args;
+        va_start(args, s);
+        writef(s, args);
+        writef("\n", args);
+        va_end(args);
+    }
+}

src/hulk/usb/xhci.d

@@ -0,0 +1,104 @@
+/**
+ * eXtensible Host Controller Interface for Universal Serial Bus
+ *
+ * Documentation:
+ * - https://wiki.osdev.org/EXtensible_Host_Controller_Interface
+ * - https://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/extensible-host-controler-interface-usb-xhci.pdf
+ */
+
+module hulk.usb.xhci;
+
+import hulk.pci;
+import hulk.hurl.a1;
+import hulk.klog;
+
+struct XHCI
+{
+    /**
+     * Located at PCI base address.
+     */
+    struct CapabilityRegisters
+    {
+        ubyte capability_length;
+        ubyte _reserved01;
+        ushort hci_version;
+        uint[3] hcs_params;
+        uint hcc_params1;
+        uint doorbell_offset;
+        uint rts_offset;
+        uint hcc_params2;
+    }
+    static assert(CapabilityRegisters.sizeof == 0x20u);
+
+    /**
+     * Located at offset capability_length from PCI base address.
+     */
+    struct OperationalRegisters
+    {
+        uint usb_command;
+        uint usb_status;
+        uint page_size;
+        uint[2] _reserved01;
+        uint dn_ctrl;
+        ulong cr_ctrl;
+        uint[4] _reserved02;
+        ulong dcbaap;
+        uint config;
+        uint _reserved03;
+    }
+    static assert(OperationalRegisters.sizeof == 0x40u);
+
+    /**
+     * Located at offset 0x400 from start of Operational Registers.
+     */
+    struct PortRegisters
+    {
+        uint portsc;
+        uint portpmsc;
+        uint portli;
+        uint porthlpmc;
+    }
+    static assert(PortRegisters.sizeof == 0x10u);
+
+    struct RuntimeRegisters
+    {
+        uint mfindex;
+        uint[7] _reserved01;
+        uint ir;
+    }
+
+    struct DoorbellRegister
+    {
+        ubyte target;
+        ubyte _reserved01;
+        ushort task_id;
+    }
+    static assert(DoorbellRegister.sizeof == 4u);
+
+    private CapabilityRegisters * m_capability_registers;
+    private OperationalRegisters * m_operational_registers;
+    private PortRegisters * m_port_registers;
+    private RuntimeRegisters * m_runtime_registers;
+    private DoorbellRegister * m_doorbell_registers;
+
+    void initialize(Pci.Device * pci_device)
+    {
+        void * base_address = pci_device.memory_ranges[0].address;
+        Klog.writefln("Found XHCI controller at address %p", base_address);
+        m_capability_registers = cast(CapabilityRegisters *)base_address;
+        m_operational_registers = cast(OperationalRegisters *)(base_address + m_capability_registers.capability_length);
+        /* TODO: confirm if 0x400 offset is from m_operation_registers or base_address. */
+        m_port_registers = cast(PortRegisters *)(cast(void *)m_operational_registers + 0x400);
+        m_runtime_registers = cast(RuntimeRegisters *)(base_address + m_capability_registers.rts_offset);
+        m_doorbell_registers = cast(DoorbellRegister *)(base_address + m_capability_registers.doorbell_offset);
+    }
+
+    static void build(Pci.Device * pci_device)
+    {
+        if (pci_device.memory_ranges[0].address != null)
+        {
+            XHCI * xhci = A1.allocate!XHCI();
+            xhci.initialize(pci_device);
+        }
+    }
+}

src/hulk/util.d

@@ -0,0 +1,17 @@
+/**
+ * HULK utility functions.
+ */
+module hulk.util;
+
+/**
+ * Round a value up to the next power of 2.
+ *
+ * @param v Value to round up.
+ * @param p Power of 2 to round up to.
+ *
+ * @return Rounded up value.
+ */
+ulong round_up_power_2(ulong v, ulong p)
+{
+    return (v + p - 1u) & ~(p - 1u);
+}

src/hulk/writef.d

@@ -0,0 +1,174 @@
+/**
+ * HULK Formatted stream writing support.
+ */
+module hulk.writef;
+
+import core.stdc.stdarg;
+
+alias ch_out_fn = void function(ubyte);
+
+/**
+ * Format a string and write characters to the given output function.
+ *
+ * @param s Format string.
+ * @param args Variable arguments structure.
+ * @param ch_out Character output function.
+ *
+ * @return Number of characters written.
+ */
+size_t writef(string s, va_list args, ch_out_fn ch_out)
+{
+    size_t length_written;
+    bool escape = false;
+    char pad = ' ';
+    size_t width;
+    foreach (char c; s)
+    {
+        if (escape)
+        {
+            if (c == 'c')
+            {
+                ulong ch;
+                va_arg(args, ch);
+                ch_out(cast(ubyte)ch);
+                length_written++;
+                escape = false;
+            }
+            else if (c == 'p')
+            {
+                ulong v;
+                va_arg(args, v);
+                length_written += write_hex(v, true, true, pad, width, ch_out);
+                escape = false;
+            }
+            else if (c == 'x')
+            {
+                ulong v;
+                va_arg(args, v);
+                length_written += write_hex(v, false, false, pad, width, ch_out);
+                escape = false;
+            }
+            else if (c == 'X')
+            {
+                ulong v;
+                va_arg(args, v);
+                length_written += write_hex(v, true, false, pad, width, ch_out);
+                escape = false;
+            }
+            else if (c == 'u')
+            {
+                ulong v;
+                va_arg(args, v);
+                length_written += write_udec(v, pad, width, ch_out);
+                escape = false;
+            }
+            else if ((c == '0') && (width == 0u))
+            {
+                pad = '0';
+            }
+            else if (('0' <= c) && (c <= '9'))
+            {
+                width = (width * 10u) + (c - '0');
+            }
+            else
+            {
+                ch_out(c);
+                escape = false;
+            }
+        }
+        else if (c == '%')
+        {
+            escape = true;
+            pad = ' ';
+            width = 0u;
+        }
+        else
+        {
+            ch_out(c);
+        }
+    }
+    return length_written;
+}
+
+/**
+ * Format a value in hexadecimal to the given output function.
+ *
+ * @param v Value to format.
+ * @param upper Whether to use uppercase letters.
+ * @param pointer Whether to format as a pointer.
+ * @param pad Pad character to use.
+ * @param width Field width.
+ * @param ch_out Character output function.
+ *
+ * @return Number of characters written.
+ */
+private size_t write_hex(ulong v, bool upper, bool pointer, char pad, size_t width, ch_out_fn ch_out)
+{
+    static __gshared const(char)[16] hex_chars_lower = "0123456789abcdef";
+    static __gshared const(char)[16] hex_chars_upper = "0123456789ABCDEF";
+    char[19] buf;
+    size_t digit;
+    size_t buf_idx;
+    do
+    {
+        ulong n = v & 0xFu;
+        buf[buf_idx] = upper ? hex_chars_upper[n] : hex_chars_lower[n];
+        v >>= 4u;
+        buf_idx++;
+        digit++;
+        if (pointer && ((digit % 4) == 0) && (v != 0u))
+        {
+            buf[buf_idx] = '_';
+            buf_idx++;
+        }
+    } while (v != 0u);
+    size_t length_written = buf_idx;
+    while (width > buf_idx)
+    {
+        ch_out(pad);
+        width--;
+        length_written++;
+    }
+    do
+    {
+        buf_idx--;
+        ch_out(buf[buf_idx]);
+    } while (buf_idx != 0u);
+    return length_written;
+}
+
+/**
+ * Format a value in decimal to the given output function.
+ *
+ * @param v Value to format.
+ * @param pad Pad character to use.
+ * @param width Field width.
+ * @param ch_out Character output function.
+ *
+ * @return Number of characters written.
+ */
+private size_t write_udec(ulong v, char pad, size_t width, ch_out_fn ch_out)
+{
+    char[20] buf;
+    size_t i;
+    do
+    {
+        ulong d = v % 10u;
+        buf[i] = cast(char)(d + '0');
+        v /= 10u;
+        i++;
+    } while (v != 0u);
+    size_t length_written = i;
+    while (width > i)
+    {
+        ch_out(pad);
+        width--;
+        length_written++;
+    }
+    do
+    {
+        i--;
+        ch_out(buf[i]);
+    } while (i != 0u);
+    return length_written;
+}

src/klog.c

@@ -1,103 +0,0 @@
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <stdarg.h>
-#include "klog.h"
-#include "kfont.h"
-#include "fb.h"
-#include "fb_text.h"
-#include "stream.h"
-#include "hos_printf.h"
-#include "mem.h"
-
-static struct {
-    size_t console_width;
-    size_t console_height;
-    size_t x;
-    size_t y;
-    bool need_shift;
-} klog;
-
-static void shift_line(void)
-{
-    uint32_t * fb = fb_addr();
-    uint32_t w = fb_width();
-    size_t console_fb_line_words = w * kfont.line_height;
-    for (size_t row = 0u; row < klog.console_height; row++)
-    {
-        memcpy32(fb, fb + console_fb_line_words, console_fb_line_words);
-        fb += console_fb_line_words;
-    }
-    fb_fill(0, kfont.line_height * (klog.console_height - 1u), w, kfont.line_height, 0u, 0x2Cu, 0x55u);
-}
-
-static void klog_fb_write1(char c)
-{
-    if (klog.need_shift)
-    {
-        shift_line();
-        klog.need_shift = false;
-    }
-    if (c == '\n')
-    {
-        if (klog.y == (klog.console_height - 1u))
-        {
-            klog.need_shift = true;
-        }
-        else
-        {
-            klog.y++;
-        }
-        klog.x = 0u;
-    }
-    else
-    {
-        int px = klog.x * kfont.advance;
-        int py = klog.y * kfont.line_height;
-        fb_text_render_char(c, px, py, 0xFFu, 0x80u, 0u);
-        klog.x++;
-        if (klog.x == klog.console_width)
-        {
-            if (klog.y == (klog.console_height - 1u))
-            {
-                klog.need_shift = true;
-            }
-            else
-            {
-                klog.y++;
-            }
-            klog.x = 0u;
-        }
-    }
-}
-
-static void klog_fb_write(const char * src, size_t length)
-{
-    for (size_t i = 0u; i < length; i++)
-    {
-        klog_fb_write1(src[i]);
-    }
-}
-
-static const stream_t klog_fb_stream = {
-    klog_fb_write,
-    klog_fb_write1,
-};
-
-void klog_init(void)
-{
-    klog.console_width = fb_width() / kfont.advance;
-    klog.console_height = fb_height() / kfont.line_height;
-    klog.x = 0u;
-    klog.y = 0u;
-    klog.need_shift = false;
-    fb_fill(0, 0, fb_width(), fb_height(), 0u, 0x2Cu, 0x55u);
-}
-
-void klog_printf(const char * fmt, ...)
-{
-    va_list va;
-    va_start(va, fmt);
-    hos_vprintf(&klog_fb_stream, fmt, va);
-    va_end(va);
-}

src/klog.h

@@ -1,7 +0,0 @@
-#ifndef KLOG_H
-#define KLOG_H
-
-void klog_init(void);
-void klog_printf(const char * fmt, ...);
-
-#endif

src/link.ld

@@ -1,41 +0,0 @@
-ENTRY(hos_start)
-
-SECTIONS
-{
-    . = 1M;
-    _hos_mem_start = .;
-
-    .text BLOCK(4K) : ALIGN(4K)
-    {
-        *(.multiboot)
-        *(.text)
-    }
-
-    .rodata BLOCK(4K) : ALIGN(4K)
-    {
-        *(.rodata)
-    }
-
-    .data BLOCK(4K) : ALIGN(4K)
-    {
-        *(.data)
-    }
-
-    _stack_size = 16K;
-    .stack (NOLOAD) : ALIGN(4K)
-    {
-        _stack_start = .;
-        . = . + _stack_size;
-        _stack_end = .;
-    }
-
-    .bss BLOCK(4K) : ALIGN(4K)
-    {
-        *(COMMON)
-        *(.bss)
-    }
-
-    . = ALIGN(4K);
-
-    _hos_mem_end = .;
-}

src/mbinfo.c

@@ -1,100 +0,0 @@
-#include "multiboot2.h"
-#include "fb.h"
-#include "mem.h"
-#include <stdint.h>
-#include "klog.h"
-#include "mm.h"
-
-static uint32_t mbinfo[2048];
-
-static void mbinfo_process_tag(const multiboot2_info_tag_t * tag)
-{
-    switch (tag->type)
-    {
-    case MULTIBOOT2_INFO_BOOT_COMMAND_LINE:
-        {
-            multiboot2_info_boot_command_line_t * cl =
-                (multiboot2_info_boot_command_line_t *)tag;
-            klog_printf("Kernel boot command line: '%s'\n", cl->string);
-        }
-        break;
-
-    case MULTIBOOT2_INFO_BOOT_LOADER_NAME:
-        {
-            multiboot2_info_boot_loader_name_t * bln =
-                (multiboot2_info_boot_loader_name_t *)tag;
-            klog_printf("Boot loader: '%s'\n", bln->string);
-        }
-        break;
-
-    case MULTIBOOT2_INFO_MEMORY_MAP:
-        {
-            multiboot2_info_memory_map_t * mmap_info =
-                (multiboot2_info_memory_map_t *)tag;
-            size_t sz = sizeof(mmap_info->header) +
-                sizeof(mmap_info->entry_size) +
-                sizeof(mmap_info->entry_version);
-            multiboot2_info_memory_map_entry_t * entry = &mmap_info->entries[0];
-            for (;;)
-            {
-                sz += mmap_info->entry_size;
-                if (sz > mmap_info->header.size)
-                {
-                    break;
-                }
-                if (entry->type == MULTIBOOT2_MEMORY_MAP_TYPE_RAM)
-                {
-                    klog_printf("Memory region %16lx : %16lx\n",
-                            entry->base_addr,
-                            entry->length);
-                    mm_register_ram_region(entry->base_addr, entry->length);
-                }
-                entry = (multiboot2_info_memory_map_entry_t *)((uintptr_t)entry + mmap_info->entry_size);
-            }
-        }
-        break;
-
-    case MULTIBOOT2_INFO_FRAMEBUFFER_INFO:
-        {
-            multiboot2_info_framebuffer_info_t * fbinfo =
-                (multiboot2_info_framebuffer_info_t *)tag;
-            fb_init((uint32_t *)(uintptr_t)fbinfo->framebuffer_addr,
-                    fbinfo->framebuffer_width,
-                    fbinfo->framebuffer_height,
-                    fbinfo->framebuffer_pitch);
-        }
-        break;
-    }
-}
-
-static void process_tags(const multiboot2_info_tag_t * tag, bool init)
-{
-    while (tag->type != 0u)
-    {
-        if ((init && (tag->type == MULTIBOOT2_INFO_FRAMEBUFFER_INFO)) ||
-                (!init && (tag->type != MULTIBOOT2_INFO_FRAMEBUFFER_INFO)))
-        {
-            mbinfo_process_tag(tag);
-        }
-        tag = multiboot2_info_next_tag(tag);
-    }
-}
-
-bool mbinfo_init(uint32_t mbinfo_addr)
-{
-    multiboot2_info_header_t * mbinfo_header = (multiboot2_info_header_t *)mbinfo_addr;
-    if (mbinfo_header->total_size <= sizeof(mbinfo))
-    {
-        memcpy32(mbinfo, mbinfo_header, mbinfo_header->total_size / 4u);
-        multiboot2_info_tag_t * tag = (multiboot2_info_tag_t *)(mbinfo + sizeof(multiboot2_info_header_t) / 4u);
-        process_tags(tag, true);
-        return true;
-    }
-    return false;
-}
-
-void mbinfo_load(void)
-{
-    multiboot2_info_tag_t * tag = (multiboot2_info_tag_t *)(mbinfo + sizeof(multiboot2_info_header_t) / 4u);
-    process_tags(tag, false);
-}

src/mbinfo.h

@@ -1,10 +0,0 @@
-#ifndef MBINFO_H
-#define MBINFO_H
-
-#include <stdint.h>
-#include <stdbool.h>
-
-bool mbinfo_init(uint32_t mbinfo_addr);
-void mbinfo_load(void);
-
-#endif

src/mem.h

@@ -1,49 +0,0 @@
-#ifndef MEM_H
-#define MEM_H
-
-#include <stddef.h>
-
-static inline void memcpy(void * dest, const void * src, size_t n)
-{
-    uint32_t r0, r1, r2;
-    __asm__ __volatile__ (
-            "cld\n\t"
-            "rep movsb"
-            : "=&c" (r0), "=&S" (r1), "=&D" (r2)
-            : "2" (dest), "1" (src), "0" (n)
-            : "memory");
-}
-
-static inline void memcpy32(void * dest, const void * src, size_t count)
-{
-    uint32_t r0, r1, r2;
-    __asm__ __volatile__ (
-            "cld\n\t"
-            "rep movsd"
-            : "=&c" (r0), "=&S" (r1), "=&D" (r2)
-            : "2" (dest), "1" (src), "0" (count)
-            : "memory");
-}
-
-static inline void * memmove(void * dest, const void * src, size_t count)
-{
-    return __builtin_memmove(dest, src, count);
-}
-
-static inline void * memset(void * dest, int val, size_t count)
-{
-    return __builtin_memset(dest, val, count);
-}
-
-static inline void memset32(void * dest, uint32_t val, size_t count)
-{
-    uint32_t r0, r1;
-    __asm__ __volatile__ (
-            "cld\n\t"
-            "rep stosl"
-            : "=&c" (r0), "=&D" (r1)
-            : "a" (val), "1" (dest), "0" (count)
-            : "memory");
-}
-
-#endif

src/mm.c

@@ -1,91 +0,0 @@
-#include "mm.h"
-
-typedef struct mm_page_entry_s {
-    size_t count;
-    struct mm_page_entry_s * next;
-} mm_region_entry_t;
-
-static mm_region_entry_t * mm_next_free_region;
-static size_t mm_free_pages;
-static size_t mm_total_ram;
-static size_t kernel_start_address;
-static size_t kernel_size;
-
-extern uint8_t _hos_mem_start;
-extern uint8_t _hos_mem_end;
-
-static void mm_add_ram_region(size_t base, size_t size)
-{
-    mm_region_entry_t * region = (mm_region_entry_t *)base;
-    size_t pages = size / PAGE_SIZE;
-    region->count = pages;
-    region->next = mm_next_free_region;
-    mm_next_free_region = region;
-    mm_total_ram += size;
-    mm_free_pages = pages;
-}
-
-void mm_register_ram_region(uint64_t base, size_t size)
-{
-    /* Ignore any RAM region above 4GB. */
-    if (base >= 0x100000000ull)
-    {
-        return;
-    }
-    if ((base + size) > 0x100000000ull)
-    {
-        size = (size_t)(0x100000000ull - base);
-    }
-    size_t end_address = mm_page_floor((size_t)base + size);
-    size_t start_address = mm_page_ceil(base);
-    size = end_address - start_address;
-    if (size < PAGE_SIZE)
-    {
-        return;
-    }
-    size_t kernel_end_address = kernel_start_address + kernel_size;
-    /* Add regions before and after kernel RAM. */
-    if (start_address < kernel_start_address)
-    {
-        /* RAM region begins before kernel RAM. */
-        size_t this_sz = size;
-        if ((start_address + this_sz) > kernel_start_address)
-        {
-            this_sz = kernel_start_address - start_address;
-        }
-        mm_add_ram_region(start_address, this_sz);
-    }
-    if ((start_address + size) > kernel_end_address)
-    {
-        /* RAM region ends after kernel RAM. */
-        size_t this_sz = size;
-        if (start_address < kernel_end_address)
-        {
-            this_sz = (start_address + size) - kernel_end_address;
-            start_address = kernel_end_address;
-        }
-        mm_add_ram_region(start_address, this_sz);
-    }
-}
-
-void mm_init(void)
-{
-    kernel_start_address = mm_page_floor((size_t)&_hos_mem_start);
-    kernel_size = mm_page_ceil((size_t)&_hos_mem_end - kernel_start_address);
-    mm_total_ram = kernel_size;
-}
-
-size_t mm_get_total_ram(void)
-{
-    return mm_total_ram;
-}
-
-size_t mm_get_kernel_address(void)
-{
-    return kernel_start_address;
-}
-
-size_t mm_get_kernel_size(void)
-{
-    return kernel_size;
-}

src/mm.h

@@ -1,25 +0,0 @@
-#ifndef MM_H
-#define MM_H
-
-#include <stdint.h>
-#include <stddef.h>
-
-#define PAGE_SIZE 4096u
-
-static inline size_t mm_page_floor(size_t bytes)
-{
-    return bytes & ~(PAGE_SIZE - 1u);
-}
-
-static inline size_t mm_page_ceil(size_t bytes)
-{
-    return (bytes + PAGE_SIZE - 1u) & ~(PAGE_SIZE - 1u);
-}
-
-void mm_init(void);
-void mm_register_ram_region(uint64_t base, size_t size);
-size_t mm_get_total_ram(void);
-size_t mm_get_kernel_address(void);
-size_t mm_get_kernel_size(void);
-
-#endif

src/multiboot2.h

@@ -1,127 +0,0 @@
-#ifndef MULTIBOOT2_H
-#define MULTIBOOT2_H
-
-#include <stdint.h>
-
-#define MULTIBOOT2_MAGIC 0xE85250D6u
-#define MULTIBOOT2_ARCHITECTURE_I386 0u
-
-typedef struct {
-    uint32_t magic;
-    uint32_t architecture;
-    uint32_t header_length;
-    uint32_t checksum;
-} multiboot2_header_t;
-#define multiboot2_header(magic, architecture, header_length) \
-    {(magic), (architecture), (header_length), (uint32_t)(0x100000000u - (magic) - (architecture) - (header_length))}
-#define multiboot2_header_default() \
-    multiboot2_header(MULTIBOOT2_MAGIC, MULTIBOOT2_ARCHITECTURE_I386, sizeof(multiboot2_header_t))
-
-typedef struct {
-    uint16_t type;
-    uint16_t flags;
-    uint32_t size;
-} multiboot2_tag_t;
-#define multiboot2_end_tag() {0u, 0u, 8u}
-
-typedef struct {
-    multiboot2_tag_t header;
-    uint32_t width;
-    uint32_t height;
-    uint32_t depth;
-    uint32_t _padding;
-} multiboot2_framebuffer_tag_t;
-#define multiboot2_framebuffer_tag(width, height, depth) \
-    {{5u, 0u, 20u}, width, height, depth}
-
-#define MULTIBOOT2_INFO_TAG_ALIGNMENT 8u
-#define MULTIBOOT2_INFO_BOOT_COMMAND_LINE 1u
-#define MULTIBOOT2_INFO_BOOT_LOADER_NAME 2u
-#define MULTIBOOT2_INFO_MODULES 3u
-#define MULTIBOOT2_INFO_BASIC_MEMORY_INFO 4u
-#define MULTIBOOT2_INFO_BIOS_BOOT_DEVICE 5u
-#define MULTIBOOT2_INFO_MEMORY_MAP 6u
-#define MULTIBOOT2_INFO_VBE_INFO 7u
-#define MULTIBOOT2_INFO_FRAMEBUFFER_INFO 8u
-#define MULTIBOOT2_INFO_ELF_SYMBOLS 9u
-#define MULTIBOOT2_INFO_APM_TABLE 10u
-#define MULTIBOOT2_INFO_EFI_32BIT_SYSTEM_TABLE_POINTER 11u
-#define MULTIBOOT2_INFO_EFI_64BIT_SYSTEM_TABLE_POINTER 12u
-#define MULTIBOOT2_INFO_SMBIOS_TABLES 13u
-#define MULTIBOOT2_INFO_ACPI_OLD_RSDP 14u
-#define MULTIBOOT2_INFO_NETWORKING_INFO 16u
-#define MULTIBOOT2_INFO_EFI_MEMORY_MAP 17u
-#define MULTIBOOT2_INFO_EFI_BOOT_SERVICES_NOT_TERMINATED 18u
-#define MULTIBOOT2_INFO_EFI_32BIT_IMAGE_HANDLE_POINTER 19u
-#define MULTIBOOT2_INFO_EFI_64BIT_IMAGE_HANDLE_POINTER 20u
-#define MULTIBOOT2_INFO_IMAGE_LOAD_BASE_PHYSICAL_ADDRESS 21u
-
-typedef struct {
-    uint32_t total_size;
-    uint32_t _reserved;
-} multiboot2_info_header_t;
-
-typedef struct {
-    uint32_t type;
-    uint32_t size;
-} multiboot2_info_tag_t;
-#define multiboot2_info_next_tag(current_tag) \
-    (multiboot2_info_tag_t *)(((uintptr_t)current_tag + current_tag->size + MULTIBOOT2_INFO_TAG_ALIGNMENT - 1u) & ~(MULTIBOOT2_INFO_TAG_ALIGNMENT - 1u))
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    char string[];
-} multiboot2_info_boot_command_line_t;
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    char string[];
-} multiboot2_info_boot_loader_name_t;
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    uint32_t mem_lower;
-    uint32_t mem_upper;
-} multiboot2_info_basic_memory_info_t;
-
-#define MULTIBOOT2_MEMORY_MAP_TYPE_RAM 1u
-#define MULTIBOOT2_MEMORY_MAP_TYPE_ACPI 3u
-#define MULTIBOOT2_MEMORY_MAP_TYPE_PRESERVE 4u
-#define MULTIBOOT2_MEMORY_MAP_TYPE_DEFECTIVE 5u
-
-typedef struct {
-    uint64_t base_addr;
-    uint64_t length;
-    uint32_t type;
-    uint32_t _reserved;
-} multiboot2_info_memory_map_entry_t;
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    uint32_t entry_size;
-    uint32_t entry_version;
-    multiboot2_info_memory_map_entry_t entries[];
-} multiboot2_info_memory_map_t;
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    uint16_t vbe_mode;
-    uint16_t vbe_interface_set;
-    uint16_t vbe_interface_off;
-    uint16_t vbe_interface_len;
-    uint8_t vbe_control_info[512];
-    uint8_t vbe_mode_info[256];
-} multiboot2_info_vbe_info_t;
-
-typedef struct {
-    multiboot2_info_tag_t header;
-    uint64_t framebuffer_addr;
-    uint32_t framebuffer_pitch;
-    uint32_t framebuffer_width;
-    uint32_t framebuffer_height;
-    uint8_t framebuffer_bpp;
-    uint8_t framebuffer_type;
-    uint8_t _reserved;
-} multiboot2_info_framebuffer_info_t;
-
-#endif

src/multiboot_header.c

@@ -1,12 +0,0 @@
-#include "multiboot2.h"
-
-/* Multiboot2 Header. */
-struct {
-    multiboot2_header_t header;
-    multiboot2_framebuffer_tag_t framebuffer_tag;
-    multiboot2_tag_t end_tag;
-} multiboot_header __attribute__((section(".multiboot"))) = {
-    multiboot2_header_default(),
-    multiboot2_framebuffer_tag(1600u, 900u, 32u),
-    multiboot2_end_tag(),
-};

src/stream.h

@@ -1,12 +0,0 @@
-#ifndef STREAM_H
-#define STREAM_H
-
-#include <stddef.h>
-#include <stdint.h>
-
-typedef struct {
-    void (*write)(const char * src, size_t length);
-    void (*write1)(char c);
-} stream_t;
-
-#endif

src/string.h

@@ -1,26 +0,0 @@
-#ifndef STRING_H
-#define STRING_H
-
-#include <stddef.h>
-
-static inline size_t strlen(const char * s)
-{
-    size_t r = 0u;
-    while (*s++ != (char)0)
-    {
-        r++;
-    }
-    return r;
-}
-
-static inline char * strcpy(char * dest, const char * src)
-{
-    return __builtin_strcpy(dest, src);
-}
-
-static inline char * strncpy(char * dest, const char * src, size_t n)
-{
-    return __builtin_strncpy(dest, src, n);
-}
-
-#endif

x86_64-elf-gcc.rb

@@ -1,9 +1,10 @@
+project_name "x86_64-elf-gcc"
 binutils_version = "2.35"
 binutils_checksum = "1b11659fb49e20e18db460d44485f09442c8c56d5df165de9461eb09c8302f85"
 gcc_version = "10.2.0"
 gcc_checksum = "b8dd4368bb9c7f0b98188317ee0254dd8cc99d1e3a18d0ff146c855fe16c1d8c"
-install_path = File.expand_path("i686-elf-gcc")
-target = "i686-elf"
+install_path = File.expand_path("x86_64-elf-gcc")
+target = "x86_64-elf"
 path_prepend "#{install_path}/bin"
 
 configure do
@@ -20,23 +21,30 @@ end
 
 default do
   unless Dir.exist?(install_path)
+    puts "Building cross compiler toolchain..."
+
     # Download archives.
+    puts "Downloading binutils..."
     download "https://ftp.gnu.org/gnu/binutils/binutils-#{binutils_version}.tar.xz",
       "#{build_dir}/binutils-#{binutils_version}.tar.xz",
       sha256sum: binutils_checksum
 
+    puts "Downloading gcc..."
     download "https://ftp.gnu.org/gnu/gcc/gcc-#{gcc_version}/gcc-#{gcc_version}.tar.xz",
       "#{build_dir}/gcc-#{gcc_version}.tar.xz",
       sha256sum: gcc_checksum
 
     # Extract archives.
+    puts "Extracting binutils..."
     sh "tar", "xJf", "binutils-#{binutils_version}.tar.xz",
       chdir: build_dir
 
+    puts "Extracting gcc..."
     sh "tar", "xJf", "gcc-#{gcc_version}.tar.xz",
       chdir: build_dir
 
     # Build binutils.
+    puts "Building binutils..."
     rm_rf "#{build_dir}/build-binutils"
     mkdir_p "#{build_dir}/build-binutils"
     cd "#{build_dir}/build-binutils" do
@@ -48,12 +56,13 @@ default do
     end
 
     # Build gcc.
+    puts "Building gcc..."
     rm_rf "#{build_dir}/build-gcc"
     mkdir_p "#{build_dir}/build-gcc"
     cd "#{build_dir}/build-gcc" do
       sh %W[../gcc-#{gcc_version}/configure
         --target=#{target} --prefix=#{install_path} --disable-nls
-        --enable-languages=c,c++ --without-headers]
+        --enable-languages=c --without-headers]
       sh "make all-gcc"
       sh "make all-target-libgcc"
       sh "make install-gcc"
@@ -61,6 +70,7 @@ default do
     end
 
     # Remove archives and build directories if everything succeeded.
+    puts "Cleaning up..."
     rm_f "#{build_dir}/binutils-#{binutils_version}.tar.xz"
     rm_rf "#{build_dir}/binutils-#{binutils_version}"
     rm_rf "#{build_dir}/build-binutils"