diff --git a/Makefile b/Makefile
index d115d03..e68c641 100644
--- a/Makefile
+++ b/Makefile
@@ -20,7 +20,9 @@ DEPENDFLAGS    := -MMD
 
 INCLUDES       := -I $(ARCH_D)
 INCLUDES       += -I src/modules
-INCLUDES       += -isystem $(EFI_INCLUDES) -isystem $(EFI_INCLUDES)/$(ARCH) -isystem $(EFI_INCLUDES)/protocol
+INCLUDES       += -isystem $(EFI_INCLUDES)
+INCLUDES       += -isystem $(EFI_INCLUDES)/$(ARCH)
+INCLUDES       += -isystem $(EFI_INCLUDES)/protocol
 
 BASEFLAGS      := -O2 -fpic -nostdlib
 BASEFLAGS      += -ffreestanding -nodefaultlibs
@@ -30,35 +32,39 @@ ifdef CPU
 BASEFLAGS      += -mcpu=$(CPU)
 endif
 
-WARNFLAGS      := -Wall -Wextra -Wshadow -Wcast-align -Wwrite-strings
-WARNFLAGS      += -Winline -Wshadow
-WARNFLAGS      += -Wno-attributes -Wno-deprecated-declarations
-WARNFLAGS      += -Wno-div-by-zero -Wno-endif-labels -Wfloat-equal
-WARNFLAGS      += -Wformat=2 -Wno-format-extra-args -Winit-self
+# Removed Flags:: -Wcast-align
+WARNFLAGS      := -Wall -Werror -Wextra -Wshadow -Wwrite-strings
+WARNFLAGS      += -Wformat=2 -Winit-self -Wfloat-equal -Winline 
 WARNFLAGS      += -Winvalid-pch -Wmissing-format-attribute
-WARNFLAGS      += -Wmissing-include-dirs -Wno-multichar
-WARNFLAGS      += -Wno-sign-compare -Wswitch -Wundef
-WARNFLAGS      += -Wno-pragmas #-Wno-unused-but-set-parameter
-WARNFLAGS      += -Wno-unused-result #-Wno-unused-but-set-variable 
-WARNFLAGS      += -Wwrite-strings -Wdisabled-optimization -Wpointer-arith
-WARNFLAGS      += -Werror
+WARNFLAGS      += -Wmissing-include-dirs -Wswitch -Wundef
+WARNFLAGS      += -Wdisabled-optimization -Wpointer-arith
+
+WARNFLAGS      += -Wno-attributes -Wno-sign-compare -Wno-multichar
+WARNFLAGS      += -Wno-div-by-zero -Wno-endif-labels -Wno-pragmas
+WARNFLAGS      += -Wno-format-extra-args -Wno-unused-result
+WARNFLAGS      += -Wno-deprecated-declarations -Wno-unused-function
+WARNFLAGS      += -Wno-unused-but-set-parameter
 
 ASFLAGS        ?= 
 
-CFLAGS         ?= 
-CFLAGS         += $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
+CFLAGS         := $(INCLUDES) $(DEPENDFLAGS) $(BASEFLAGS) $(WARNFLAGS)
+CFLAGS         += -std=c11 -fpic -fshort-wchar
+CFLAGS         += -mno-red-zone -fno-stack-protector 
 CFLAGS         += -DGIT_VERSION="L\"$(VERSION)\""
-CFLAGS         += -std=c11 -fno-stack-protector -fpic -fshort-wchar -mno-red-zone
-CFLAGS         += -DEFI_DEBUG=0 -DEFI_DEBUG_CLEAR_MEMORY=0 -DGNU_EFI_USE_MS_ABI -DHAVE_USE_MS_ABI #-DEFI_FUNCTION_WRAPPER 
+CFLAGS         += -DEFI_DEBUG=0 -DEFI_DEBUG_CLEAR_MEMORY=0
+CFLAGS         += -DGNU_EFI_USE_MS_ABI -DHAVE_USE_MS_ABI
+#CFLAGS        += -DEFI_FUNCTION_WRAPPER 
 
+BOOT_CFLAGS	   := -I src/boot $(CFLAGS)
 ifdef MAX_HRES
-CFLAGS         += -DMAX_HRES=$(MAX_HRES)
+BOOT_CFLAGS    += -DMAX_HRES=$(MAX_HRES)
 endif
 
-LDFLAGS        ?= 
-LDFLAGS        += -L $(BUILD_D) -ggdb
-LDFLAGS        += -nostdlib -znocombreloc -shared -Bsymbolic -fPIC -nostartfiles 
-LDFLAGS        += -L $(EFI_ARCH_DIR)/lib -L $(EFI_ARCH_DIR)/gnuefi
+LDFLAGS        := -L $(BUILD_D) -ggdb -fPIC -shared
+LDFLAGS        += -nostdlib -znocombreloc -Bsymbolic -nostartfiles 
+
+BOOT_LDFLAGS   := $(LDFLAGS)
+BOOT_LDFLAGS   += -L $(EFI_ARCH_DIR)/lib -L $(EFI_ARCH_DIR)/gnuefi
 
 AS             ?= $(CROSS)as
 AR             ?= $(CROSS)ar
@@ -69,6 +75,11 @@ OBJC           := $(CROSS)objcopy
 OBJD           := $(CROSS)objdump
 
 INIT_DEP       := $(BUILD_D)/.builddir
+
+BOOT_SRCS      := $(wildcard src/boot/*.c)
+BOBJS          += $(patsubst src/boot/%,$(BUILD_D)/boot/%,$(patsubst %,%.o,$(BOOT_SRCS)))
+BDEPS          := $(patsubst src/boot/%,$(BUILD_D)/boot/%,$(patsubst %,%.d,$(BOOT_SRCS)))
+
 ARCH_SRCS      := $(wildcard $(ARCH_D)/*.s)
 ARCH_SRCS      += $(wildcard $(ARCH_D)/*.c)
 KOBJS          += $(patsubst $(ARCH_D)/%,$(BUILD_D)/arch/%,$(patsubst %,%.o,$(ARCH_SRCS)))
@@ -80,7 +91,13 @@ QEMU           ?= qemu-system-x86_64
 GDBPORT        ?= 27006
 CPUS           ?= 2
 OVMF           ?= assets/ovmf/x64/OVMF.fd 
-QEMUOPTS       := -bios $(OVMF) -hda $(BUILD_D)/fs.img -smp $(CPUS) -m 512 $(QEMUEXTRA) -d guest_errors
+
+QEMUOPTS       := -pflash $(OVMF)
+QEMUOPTS       += -drive file=$(BUILD_D)/fs.img,format=raw
+QEMUOPTS       += -smp $(CPUS)
+QEMUOPTS       += -m 512
+QEMUOPTS       += -d guest_errors
+QEMUOPTS       += $(QEMUEXTRA)
 
 
 all: $(BUILD_D)/fs.img
@@ -88,6 +105,7 @@ init: $(INIT_DEP)
 
 $(INIT_DEP):
 	mkdir -p $(BUILD_D) $(patsubst %,$(BUILD_D)/d.%,$(MODULES))
+	mkdir -p $(BUILD_D)/boot
 	mkdir -p $(BUILD_D)/arch
 	touch $(INIT_DEP)
 
@@ -108,32 +126,47 @@ $(BUILD_D)/.version:
 $(EFI_LIB):
 	make -C external/gnu-efi all
 
-$(BUILD_D)/kernel.elf: $(KOBJS) $(MOD_TARGETS) $(EFI_LIB)
-	$(LD) $(LDFLAGS) -T $(EFI_LDS) -o $@ \
-		$(EFI_CRT_OBJ) $(KOBJS) $(patsubst %,-l%,$(MODULES)) -lefi -lgnuefi
+$(BUILD_D)/kernel.elf: $(KOBJS) $(MOD_TARGETS) $(ARCH_D)/kernel.ld
+	$(LD) $(LDFLAGS) -T $(ARCH_D)/kernel.ld -o $@ $(KOBJS) $(patsubst %,-l%,$(MODULES))
 
-$(BUILD_D)/kernel.efi: $(BUILD_D)/kernel.elf
+$(BUILD_D)/boot.elf: $(BOBJS) $(EFI_LIB)
+	$(LD) $(BOOT_LDFLAGS) -T $(EFI_LDS) -o $@ \
+		$(EFI_CRT_OBJ) $(BOBJS) $(patsubst %,-l%,$(MODULES)) -lefi -lgnuefi
+
+$(BUILD_D)/boot.efi: $(BUILD_D)/boot.elf
 	objcopy -j .text -j .sdata -j .data -j .dynamic \
 	-j .dynsym  -j .rel -j .rela -j .reloc \
 	--target=efi-app-$(ARCH) $^ $@
 
-$(BUILD_D)/kernel.debug.efi: $(BUILD_D)/kernel.elf
+$(BUILD_D)/boot.debug.efi: $(BUILD_D)/boot.elf
 	objcopy -j .text -j .sdata -j .data -j .dynamic \
 	-j .dynsym  -j .rel -j .rela -j .reloc \
 	-j .debug_info -j .debug_abbrev -j .debug_loc -j .debug_str \
 	-j .debug_aranges -j .debug_line -j .debug_macinfo \
 	--target=efi-app-$(ARCH) $^ $@
 
-$(BUILD_D)/%.dump: $(BUILD_D)/%.efi
+$(BUILD_D)/%.elf.dump: $(BUILD_D)/%.elf
 	$(OBJD) -D -S $< > $@
 
+$(BUILD_D)/%.bin.dump: $(BUILD_D)/%.bin
+	$(OBJD) -D $< > $@
+
+$(BUILD_D)/%.bin: $(BUILD_D)/%.elf
+	$(OBJC) $< -O binary $@
+
+$(BUILD_D)/boot/%.s.o: src/boot/%.s $(INIT_DEP)
+	$(AS) $(ASFLAGS) -o $@ $<
+
+$(BUILD_D)/boot/%.c.o: src/boot/%.c $(INIT_DEP)
+	$(CC) $(BOOT_CFLAGS) -c -o $@ $<
+
 $(BUILD_D)/arch/%.s.o: $(ARCH_D)/%.s $(INIT_DEP)
 	$(AS) $(ASFLAGS) -o $@ $<
 
 $(BUILD_D)/arch/%.c.o: $(ARCH_D)/%.c $(INIT_DEP)
 	$(CC) $(CFLAGS) -c -o $@ $<
 
-$(BUILD_D)/fs.img: $(BUILD_D)/kernel.efi
+$(BUILD_D)/fs.img: $(BUILD_D)/boot.efi $(BUILD_D)/kernel.bin
 	$(eval TEMPFILE := $(shell mktemp --suffix=.img))
 	dd if=/dev/zero of=$@.tmp bs=512 count=93750
 	$(PARTED) $@.tmp -s -a minimal mklabel gpt
@@ -143,7 +176,9 @@ $(BUILD_D)/fs.img: $(BUILD_D)/kernel.efi
 	mformat -i $(TEMPFILE) -h 32 -t 32 -n 64 -c 1
 	mmd -i $(TEMPFILE) ::/EFI
 	mmd -i $(TEMPFILE) ::/EFI/BOOT
-	mcopy -i $(TEMPFILE) $^ ::/EFI/BOOT/BOOTX64.efi
+	mcopy -i $(TEMPFILE) $(BUILD_D)/boot.efi ::/EFI/BOOT/BOOTX64.efi
+	mcopy -i $(TEMPFILE) $(BUILD_D)/kernel.bin ::/kernel.bin
+	mlabel -i $(TEMPFILE) ::Popcorn_OS
 	dd if=$(TEMPFILE) of=$@.tmp bs=512 count=91669 seek=2048 conv=notrunc
 	rm $(TEMPFILE)
 	mv $@.tmp $@
@@ -159,7 +194,7 @@ qemu: $(BUILD_D)/fs.img
 qemu-window: $(BUILD_D)/fs.img
 	"$(QEMU)" $(QEMUOPTS)
 
-qemu-gdb: $(BUILD_D)/fs.img $(BUILD_D)/kernel.debug.efi
+qemu-gdb: $(BUILD_D)/fs.img $(BUILD_D)/boot.debug.efi
 	"$(QEMU)" $(QEMUOPTS) -S -D popcorn-qemu.log -s
 
 # vim: ft=make ts=4
diff --git a/external/gnu-efi b/external/gnu-efi
index d031099..99d9468 160000
--- a/external/gnu-efi
+++ b/external/gnu-efi
@@ -1 +1 @@
-Subproject commit d03109958fa45865b77cf1fdf92c3b145a7dc7a0
+Subproject commit 99d94682de590719f9333fcf091910a9581b44c0
diff --git a/src/arch/x86_64/boot.s b/src/arch/x86_64/boot.s
new file mode 100755
index 0000000..a5895f1
--- /dev/null
+++ b/src/arch/x86_64/boot.s
@@ -0,0 +1,12 @@
+; boot.s -- Kernel start location.
+
+[BITS 64]
+ALIGN 4
+
+SECTION .text
+[GLOBAL start]
+
+start:
+	; Load multiboot header location
+	mov ebx, 0xdeadbeef
+	jmp $
diff --git a/src/arch/x86_64/config.mk b/src/arch/x86_64/config.mk
index 9456356..1c53532 100644
--- a/src/arch/x86_64/config.mk
+++ b/src/arch/x86_64/config.mk
@@ -1,5 +1,5 @@
 AS := nasm
-ASFLAGS := -felf
+ASFLAGS := -felf64
 LDFLAGS := -m elf_x86_64
 CFLAGS := -march=nocona -m64
 
diff --git a/src/arch/x86_64/kernel.ld b/src/arch/x86_64/kernel.ld
new file mode 100755
index 0000000..4913206
--- /dev/null
+++ b/src/arch/x86_64/kernel.ld
@@ -0,0 +1,26 @@
+ENTRY(start)
+SECTIONS
+{
+	. = 0x100000;
+
+	.text : {
+		code = .;
+		*(.text)
+		. = ALIGN(4096);
+	}
+
+	.data : {
+		 data = .;
+		 *(.data)
+		 *(.rodata)
+		 . = ALIGN(4096);
+	}
+
+	.bss : {
+		bss = .;
+		*(.bss)
+		. = ALIGN(4096);
+	}
+
+	end = .;
+}
diff --git a/src/arch/x86_64/console.c b/src/boot/console.c
similarity index 100%
rename from src/arch/x86_64/console.c
rename to src/boot/console.c
diff --git a/src/arch/x86_64/console.h b/src/boot/console.h
similarity index 100%
rename from src/arch/x86_64/console.h
rename to src/boot/console.h
diff --git a/src/boot/loader.c b/src/boot/loader.c
new file mode 100644
index 0000000..25bc13d
--- /dev/null
+++ b/src/boot/loader.c
@@ -0,0 +1,75 @@
+#include "loader.h"
+#include "utility.h"
+
+static CHAR16 kernel_name[] = KERNEL_FILENAME;
+
+static EFI_STATUS loader_load_file(EFI_FILE_PROTOCOL *root, void **kernel_image, UINT64 *len) {
+	EFI_STATUS status;
+
+	EFI_FILE_PROTOCOL *handle = 0;
+	status = root->Open(root, &handle, kernel_name, EFI_FILE_MODE_READ, 0);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to open kernel file handle");
+
+	EFI_FILE_INFO *info = LibFileInfo(handle);
+    if (info->FileSize == 0)
+        return EFI_NOT_FOUND;
+
+    UINTN count = ((info->FileSize - 1) / 0x1000) + 1;
+    EFI_PHYSICAL_ADDRESS addr = 0x100000; // Try to load the kernel in at 1MiB
+    EFI_MEMORY_TYPE memType = 0xFFFFFFFF;  // Special value to tell the kernel it's here
+    status = ST->BootServices->AllocatePages(AllocateAddress, memType, count, &addr);
+    if (status == EFI_NOT_FOUND) {
+        // couldn't get the address we wanted, try loading the kernel anywhere
+        status = ST->BootServices->AllocatePages(AllocateAnyPages, memType, count, &addr);
+    }
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate kernel pages");
+
+    UINTN buffer_size = count * 0x1000;
+    void *buffer = (void*)addr;
+    status = handle->Read(handle, &buffer_size, &buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to read kernel to memory");
+
+	*len = buffer_size;
+	*kernel_image = buffer;
+	return EFI_SUCCESS;
+}
+
+EFI_STATUS loader_load_kernel(void **kernel_image, UINT64 *len) {
+    if (kernel_image == 0 || len == 0)
+        CHECK_EFI_STATUS_OR_RETURN(EFI_INVALID_PARAMETER, "NULL kernel_image pointer or size");
+
+	EFI_STATUS status;
+
+	// First, find all the handles that support the filesystem protocol. Call
+	UINTN size = 0;
+	EFI_GUID fs_guid = EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID;
+	status = ST->BootServices->LocateHandle(ByProtocol, &fs_guid, NULL, &size, NULL);
+	if (status != EFI_BUFFER_TOO_SMALL) {
+		CHECK_EFI_STATUS_OR_RETURN(status, "Failed to find number of filesystem handles");
+	} else if (size == 0) {
+		CHECK_EFI_STATUS_OR_RETURN(EFI_NO_MEDIA, "Found zero filesystem handles");
+	}
+
+	EFI_HANDLE *buffer = 0;
+    status = ST->BootServices->AllocatePool(EfiLoaderData, size, (void**)&buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate buffer of filesystem handles");
+
+	status = ST->BootServices->LocateHandle(ByProtocol, &fs_guid, NULL, &size, buffer);
+	CHECK_EFI_STATUS_OR_RETURN(status, "Failed to find filesystem handles");
+
+	unsigned num_fs = size / sizeof(EFI_HANDLE);
+	EFI_HANDLE *fss = (EFI_HANDLE*)buffer;
+
+	for (unsigned i = 0; i < num_fs; ++i) {
+		EFI_FILE_HANDLE root = LibOpenRoot(fss[i]);
+
+		status = loader_load_file(root, kernel_image, len);
+        if (status == EFI_NOT_FOUND)
+            continue;
+
+		CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load kernel");
+        return EFI_SUCCESS;
+	}
+
+    return EFI_NOT_FOUND;
+}
diff --git a/src/boot/loader.h b/src/boot/loader.h
new file mode 100644
index 0000000..6829d38
--- /dev/null
+++ b/src/boot/loader.h
@@ -0,0 +1,8 @@
+#pragma once
+#include <efi.h>
+
+#ifndef KERNEL_FILENAME
+#define KERNEL_FILENAME L"kernel.bin"
+#endif
+
+EFI_STATUS loader_load_kernel(void **kernel_image, UINT64 *len);
diff --git a/src/arch/x86_64/main.c b/src/boot/main.c
similarity index 63%
rename from src/arch/x86_64/main.c
rename to src/boot/main.c
index 841e8c5..b89b078 100644
--- a/src/arch/x86_64/main.c
+++ b/src/boot/main.c
@@ -2,6 +2,7 @@
 #include <efilib.h>
 
 #include "console.h"
+#include "loader.h"
 #include "memory.h"
 #include "utility.h"
 
@@ -21,18 +22,31 @@ efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
 	// be sure if the console was fully set up
 	status = con_initialize(GIT_VERSION);
 	CHECK_EFI_STATUS_OR_RETURN(status, "con_initialize");
-
 	// From here on out, use CHECK_EFI_STATUS_OR_FAIL instead
 	// because the console is now set up
 
-	/*
-	Print(L" SystemTable: %x\n", SystemTable);
-	if (SystemTable)
-		Print(L"	  ConOut: %x\n", SystemTable->ConOut);
-	if (SystemTable->ConOut)
-		Print(L"OutputString: %x\n", SystemTable->ConOut->OutputString);
-	*/
+	// Get info about the image
+	con_status_begin(L"Gathering image information...");
+	EFI_LOADED_IMAGE *info = 0;
+	EFI_GUID image_proto = EFI_LOADED_IMAGE_PROTOCOL_GUID;
+	status = ST->BootServices->HandleProtocol(ImageHandle, &image_proto, (void **)&info);
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	con_status_ok();
 
+	con_status_begin(L"Virtualizing memory...");
+    status = memory_virtualize();
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	con_status_ok();
+
+    con_status_begin(L"Loading kernel into memory...");
+    void *kernel_image = NULL;
+	UINT64 len = 0;
+    status = loader_load_kernel(&kernel_image, &len);
+    CHECK_EFI_STATUS_OR_FAIL(status);
+	Print(L" %u bytes at 0x%x", len, kernel_image);
+    con_status_ok();
+
+    /*
 	dump_memory_map();
 
 	UINTN memmap_size = 0;
@@ -54,6 +68,7 @@ efi_main (EFI_HANDLE ImageHandle, EFI_SYSTEM_TABLE *SystemTable)
 		memmap_size, desc_size, desc_version, memmap);
 	CHECK_EFI_STATUS_OR_FAIL(status);
 	con_status_ok();
+    */
 
 	while (1) __asm__("hlt");
 	return status;
diff --git a/src/arch/x86_64/memory.c b/src/boot/memory.c
similarity index 68%
rename from src/arch/x86_64/memory.c
rename to src/boot/memory.c
index 60d84b3..7fc1a57 100644
--- a/src/arch/x86_64/memory.c
+++ b/src/boot/memory.c
@@ -24,18 +24,34 @@ const CHAR16 *memory_type_names[] = {
     L"EfiPersistentMemory",
 };
 
-const CHAR16 *memory_type_name(UINT32 value) {
+static const CHAR16 *memory_type_name(UINT32 value) {
     if (value >= (sizeof(memory_type_names)/sizeof(CHAR16*)))
         return L"Bad Type Value";
     return memory_type_names[value];
 }
 
-EFI_STATUS get_memory_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
+void EFIAPI memory_update_addresses(EFI_EVENT UNUSED *event, void UNUSED *context) {
+    ST->RuntimeServices->ConvertPointer(0, (void **)&BS);
+    ST->RuntimeServices->ConvertPointer(0, (void **)&ST);
+}
+
+EFI_STATUS memory_virtualize() {
+    EFI_STATUS status;
+    EFI_EVENT event;
+
+    status = ST->BootServices->CreateEvent(EVT_SIGNAL_VIRTUAL_ADDRESS_CHANGE,
+            TPL_CALLBACK, (EFI_EVENT_NOTIFY)&memory_update_addresses, NULL, &event);
+    CHECK_EFI_STATUS_OR_RETURN(status, "Failed to create memory update event");
+
+    return status;
+}
+
+EFI_STATUS memory_get_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
                           UINTN *key, UINTN *desc_size, UINT32 *desc_version) {
     EFI_STATUS status;
 
     UINTN needs_size = 0;
-    status = BS->GetMemoryMap(&needs_size, 0, key, desc_size, desc_version);
+    status = ST->BootServices->GetMemoryMap(&needs_size, 0, key, desc_size, desc_version);
     if (status != EFI_BUFFER_TOO_SMALL) {
         CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
     }
@@ -43,20 +59,20 @@ EFI_STATUS get_memory_map(EFI_MEMORY_DESCRIPTOR **buffer, UINTN *buffer_size,
     // Give some extra buffer to account for changes.
     *buffer_size = needs_size + 256;
     Print(L"Trying to load memory map with size %d.\n", *buffer_size);
-    status = BS->AllocatePool(EfiLoaderData, *buffer_size, (void**)buffer);
+    status = ST->BootServices->AllocatePool(EfiLoaderData, *buffer_size, (void**)buffer);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to allocate space for memory map");
 
-    status = BS->GetMemoryMap(buffer_size, *buffer, key, desc_size, desc_version);
+    status = ST->BootServices->GetMemoryMap(buffer_size, *buffer, key, desc_size, desc_version);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to load memory map");
     return EFI_SUCCESS;
 }
 
-EFI_STATUS dump_memory_map() {
+EFI_STATUS memory_dump_map() {
     EFI_MEMORY_DESCRIPTOR *buffer;
     UINTN buffer_size, desc_size, key;
     UINT32 desc_version;
 
-    EFI_STATUS status = get_memory_map(&buffer, &buffer_size, &key,
+    EFI_STATUS status = memory_get_map(&buffer, &buffer_size, &key,
         &desc_size, &desc_version);
     CHECK_EFI_STATUS_OR_RETURN(status, "Failed to get memory map");
 
@@ -79,6 +95,6 @@ EFI_STATUS dump_memory_map() {
         d = (EFI_MEMORY_DESCRIPTOR *)((uint8_t *)d + desc_size);
     }
 
-    BS->FreePool(buffer);
+    ST->BootServices->FreePool(buffer);
     return EFI_SUCCESS;
-}
\ No newline at end of file
+}
diff --git a/src/arch/x86_64/memory.h b/src/boot/memory.h
similarity index 60%
rename from src/arch/x86_64/memory.h
rename to src/boot/memory.h
index 970345b..8adf4ce 100644
--- a/src/arch/x86_64/memory.h
+++ b/src/boot/memory.h
@@ -1,13 +1,13 @@
 #pragma once
 #include <efi.h>
 
-const CHAR16 *memory_type_name(UINT32 value);
+EFI_STATUS memory_virtualize();
 
-EFI_STATUS get_memory_map(
+EFI_STATUS memory_get_map(
     EFI_MEMORY_DESCRIPTOR **buffer,
     UINTN *buffer_size,
     UINTN *key,
     UINTN *desc_size,
     UINT32 *desc_version);
 
-EFI_STATUS dump_memory_map();
\ No newline at end of file
+EFI_STATUS memory_dump_map();
diff --git a/src/arch/x86_64/utility.c b/src/boot/utility.c
similarity index 100%
rename from src/arch/x86_64/utility.c
rename to src/boot/utility.c
diff --git a/src/arch/x86_64/utility.h b/src/boot/utility.h
similarity index 91%
rename from src/arch/x86_64/utility.h
rename to src/boot/utility.h
index 58f8c86..06e2d9e 100644
--- a/src/arch/x86_64/utility.h
+++ b/src/boot/utility.h
@@ -2,6 +2,8 @@
 #include <efilib.h>
 #include "console.h"
 
+#define UNUSED __attribute__((unused))
+
 const CHAR16 *util_error_message(EFI_STATUS status);
 
 #define CHECK_EFI_STATUS_OR_RETURN(s, msg, ...)   \