x86_64/pre: remove ported implementation

11 files changed, 0 insertions, 754 deletions

diff --git a/arch/x86_64/pre/src/memory/allocator/area_frame_allocator.cpp b/arch/x86_64/pre/src/memory/allocator/area_frame_allocator.cpp
deleted file mode 100644
index 3105023..0000000
--- a/arch/x86_64/pre/src/memory/allocator/area_frame_allocator.cpp
+++ /dev/null
@@ -1,88 +0,0 @@
-#include "arch/memory/allocator/area_frame_allocator.hpp"
-
-#include "arch/exception_handling/assert.hpp"
-
-#include <algorithm>
-#include <array>
-#include <ranges>
-
-namespace teachos::arch::memory::allocator
-{
-  area_frame_allocator::area_frame_allocator(multiboot::memory_information const & mem_info)
-      : next_free_frame()
-      , current_area(std::nullopt)
-      , memory_areas(mem_info.areas)
-      , kernel_start(physical_frame::containing_address(mem_info.kernel_start))
-      , kernel_end(physical_frame::containing_address(mem_info.kernel_end))
-      , multiboot_start(physical_frame::containing_address(mem_info.multiboot_start))
-      , multiboot_end(physical_frame::containing_address(mem_info.multiboot_end))
-  {
-    choose_next_area();
-  }
-
-  auto area_frame_allocator::choose_next_area() -> void
-  {
-    current_area = std::nullopt;
-    auto next_area_with_free_frames = memory_areas | std::views::filter([this](auto const & area) {
-                                        auto address = area.base_address + area.area_length - 1;
-                                        return physical_frame::containing_address(address) >= next_free_frame;
-                                      });
-
-    auto const lowest_area_with_free_frames = std::ranges::min_element(
-        next_area_with_free_frames, [](auto const & a, auto const & b) { return a.base_address < b.base_address; });
-
-    if (lowest_area_with_free_frames != next_area_with_free_frames.end())
-    {
-      current_area = *lowest_area_with_free_frames;
-      // Update the `next_free_frame` according to the new memory area
-      auto const start_frame = physical_frame::containing_address(current_area.value().base_address);
-      if (next_free_frame < start_frame)
-      {
-        next_free_frame = start_frame;
-      }
-    }
-  }
-
-  auto area_frame_allocator::allocate_frame() -> std::optional<physical_frame>
-  {
-    // Only try to allocate memory if current_area is not null, because
-    // the current_area is null if there is no more available memory.
-    if (!current_area.has_value())
-    {
-      return std::nullopt;
-    }
-
-    auto const address = current_area.value().base_address + current_area.value().area_length - 1;
-    physical_frame current_area_last_frame = physical_frame::containing_address(address);
-
-    if (next_free_frame > current_area_last_frame)
-    {
-      // All frames of current area are used, switch to next area.
-      choose_next_area();
-    }
-    else if (next_free_frame >= kernel_start && next_free_frame <= kernel_end)
-    {
-      // `physical_frame` is used by the kernel or multiboot information structure.
-      next_free_frame = allocator::physical_frame{kernel_end.frame_number + 1};
-    }
-    else if (next_free_frame >= multiboot_start && next_free_frame <= multiboot_end)
-    {
-      // `physical_frame` is used by the kernel or multiboot information structure.
-      next_free_frame = allocator::physical_frame{multiboot_end.frame_number + 1};
-    }
-    else
-    {
-      // Frame is unused, increment `next_free_frame` and return it.
-      next_free_frame.frame_number += 1;
-      return next_free_frame;
-    }
-
-    // `physical_frame` was not valid, try it again with the updated `next_free_frame`.
-    return allocate_frame();
-  }
-
-  auto area_frame_allocator::deallocate_frame(physical_frame const & physical_frame) -> void
-  {
-    (void)physical_frame;
-  }
-}  // namespace teachos::arch::memory::allocator
diff --git a/arch/x86_64/pre/src/memory/allocator/tiny_frame_allocator.cpp b/arch/x86_64/pre/src/memory/allocator/tiny_frame_allocator.cpp
deleted file mode 100644
index 3cdf9c7..0000000
--- a/arch/x86_64/pre/src/memory/allocator/tiny_frame_allocator.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-#include "arch/memory/allocator/tiny_frame_allocator.hpp"
-
-#include "arch/exception_handling/panic.hpp"
-
-namespace teachos::arch::memory::allocator
-{
-  auto tiny_frame_allocator::allocate_frame() -> std::optional<physical_frame>
-  {
-    for (auto & frame_option : frames)
-    {
-      if (frame_option.has_value())
-      {
-        auto value = frame_option;
-        frame_option.reset();
-        return value;
-      }
-    }
-    return std::nullopt;
-  }
-
-  auto tiny_frame_allocator::deallocate_frame(physical_frame const & physical_frame) -> void
-  {
-    for (auto & frame_option : frames)
-    {
-      if (!frame_option.has_value())
-      {
-        frame_option.emplace(physical_frame);
-        return;
-      }
-    }
-    exception_handling::panic(
-        "[Tiny Frame Allocator] Attempted to deallocate more than the 3 frames, that can be held");
-  }
-}  // namespace teachos::arch::memory::allocator
diff --git a/arch/x86_64/pre/src/memory/main.cpp b/arch/x86_64/pre/src/memory/main.cpp
deleted file mode 100644
index b5980db..0000000
--- a/arch/x86_64/pre/src/memory/main.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-#include "arch/memory/main.hpp"
-
-#include "arch/exception_handling/assert.hpp"
-#include "arch/kernel/cpu/control_register.hpp"
-#include "arch/kernel/cpu/msr.hpp"
-#include "arch/memory/allocator/area_frame_allocator.hpp"
-#include "arch/memory/allocator/concept.hpp"
-#include "arch/memory/heap/global_heap_allocator.hpp"
-#include "arch/memory/paging/active_page_table.hpp"
-#include "arch/memory/paging/kernel_mapper.hpp"
-
-#include <optional>
-
-namespace teachos::arch::memory
-{
-  namespace
-  {
-    std::optional<allocator::area_frame_allocator> static frame_allocator;
-
-    auto create_frame_allocator(multiboot::memory_information const & memory_information)
-        -> allocator::area_frame_allocator &
-    {
-      frame_allocator.emplace(memory_information);
-      return frame_allocator.value();
-    }
-
-    auto get_frame_allocator() -> allocator::area_frame_allocator &
-    {
-      exception_handling::assert(frame_allocator.has_value(),
-                                 "[Initialization] Frame allocator has not been created yet");
-      return frame_allocator.value();
-    }
-  }  // namespace
-
-  auto remap_heap(std::size_t heap_start, std::size_t heap_size, paging::entry::bitset additional_flags = {}) -> void
-  {
-    decltype(auto) allocator = get_frame_allocator();
-    decltype(auto) active_table = paging::active_page_table::create_or_get();
-    auto const start_page = paging::virtual_page::containing_address(heap_start);
-    auto const end_page = ++(paging::virtual_page::containing_address(heap_start + heap_size - 1));
-
-    paging::page_container::iterator const begin{start_page};
-    paging::page_container::iterator const end{end_page};
-    paging::page_container const pages{begin, end};
-
-    constexpr auto base_flags = paging::entry::WRITABLE;
-    auto const flags = base_flags | additional_flags;
-
-    for (auto const & page : pages)
-    {
-      active_table.map_page_to_next_free_frame(allocator, page, flags);
-    }
-  }
-
-  auto initialize_memory_management() -> void
-  {
-    bool static has_been_called = false;
-    arch::exception_handling::assert(!has_been_called,
-                                     "[Initialization] Memory management has already been initialized");
-    has_been_called = true;
-
-    auto const memory_information = multiboot::read_multiboot2();
-    decltype(auto) allocator = create_frame_allocator(memory_information);
-
-    kernel::cpu::set_cr0_bit(kernel::cpu::cr0_flags::WRITE_PROTECT);
-    kernel::cpu::set_efer_bit(kernel::cpu::efer_flags::NXE);
-
-    paging::kernel_mapper kernel(allocator, memory_information);
-    kernel.remap_kernel();
-    video::vga::text::write("Kernel remapping successful", video::vga::text::common_attributes::green_on_black);
-    video::vga::text::newline();
-
-    remap_heap(heap::KERNEL_HEAP_START, heap::KERNEL_HEAP_SIZE);
-    video::vga::text::write("Heap remapping successful", video::vga::text::common_attributes::green_on_black);
-    video::vga::text::newline();
-  }
-}  // namespace teachos::arch::memory
diff --git a/arch/x86_64/pre/src/memory/multiboot/elf_symbols_section.cpp b/arch/x86_64/pre/src/memory/multiboot/elf_symbols_section.cpp
deleted file mode 100644
index 3105120..0000000
--- a/arch/x86_64/pre/src/memory/multiboot/elf_symbols_section.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "arch/memory/multiboot/elf_symbols_section.hpp"
-
-namespace teachos::arch::memory::multiboot
-{
-  auto elf_section_flags::contains_flags(std::bitset<64U> other) const -> bool
-  {
-    return (flags & other) == other;
-  }
-
-  auto elf_section_header::is_null() const -> bool
-  {
-    return name_table_index == 0U && type == elf_section_type::INACTIVE && flags == elf_section_flags(0U) &&
-           physical_address == 0U && file_offset == 0U && additional_information == 0U && address_alignment == 0U &&
-           fixed_table_entry_size == 0U;
-  }
-}  // namespace teachos::arch::memory::multiboot
diff --git a/arch/x86_64/pre/src/memory/multiboot/reader.cpp b/arch/x86_64/pre/src/memory/multiboot/reader.cpp
deleted file mode 100644
index b05e6b3..0000000
--- a/arch/x86_64/pre/src/memory/multiboot/reader.cpp
+++ /dev/null
@@ -1,135 +0,0 @@
-#include "arch/memory/multiboot/reader.hpp"
-
-#include "arch/boot/pointers.hpp"
-#include "arch/exception_handling/assert.hpp"
-#include "multiboot2/information.hpp"
-// #include "arch/memory/multiboot/elf_symbols_section.hpp"
-// #include "arch/memory/multiboot/info.hpp"
-
-#include <algorithm>
-#include <ranges>
-
-// namespace teachos::arch::memory::multiboot
-// {
-//   namespace
-//   {
-//     template<typename T>
-//       requires std::is_pointer<T>::value
-//     auto align_to_8_byte_boundary(T ptr, uint32_t size) -> T
-//     {
-//       return reinterpret_cast<T>(reinterpret_cast<uint8_t *>(ptr) + ((size + 7) & ~7));
-//     }
-
-//     auto process_memory_map(memory_map_header * mminfo) -> memory_area_container
-//     {
-//       auto const expected_entry_size = mminfo->entry_size;
-//       auto constexpr actual_entry_size = sizeof(memory_area);
-//       exception_handling::assert(expected_entry_size == actual_entry_size,
-//                                  "[Multiboot Reader] Unexpected memory area entry size");
-
-//       auto const total_size = mminfo->info.size;
-//       auto const total_entries_size = total_size - sizeof(memory_map_header) + actual_entry_size;
-//       auto const number_of_entries = total_entries_size / actual_entry_size;
-
-//       auto const begin = memory_area_container::iterator{&mminfo->entries};
-//       auto const end = begin + number_of_entries;
-//       return memory_area_container{begin, end};
-//     }
-
-//     auto process_elf_sections(elf_symbols_section_header * symbol, std::size_t & kernel_start, std::size_t &
-//     kernel_end)
-//         -> elf_section_header_container
-//     {
-//       auto const expected_entry_size = symbol->entry_size;
-//       auto constexpr actual_entry_size = sizeof(elf_section_header);
-//       exception_handling::assert(expected_entry_size == actual_entry_size,
-//                                  "[Multiboot Reader] Unexpected elf section header entry size");
-
-//       auto const expected_total_size = symbol->info.size;
-//       auto const actual_total_entry_size = actual_entry_size * symbol->number_of_sections;
-//       auto constexpr actual_total_section_size = sizeof(elf_symbols_section_header) - sizeof(uint32_t);
-//       auto const actual_total_size = actual_total_entry_size + actual_total_section_size;
-//       exception_handling::assert(expected_total_size == actual_total_size,
-//                                  "[Multiboot Reader] Unexpected elf symbols section header total size");
-
-//       auto const begin = elf_section_header_container::iterator{reinterpret_cast<elf_section_header
-//       *>(&symbol->end)}; auto const end = begin + symbol->number_of_sections;
-//       exception_handling::assert(begin->is_null(),
-//                                  "[Multiboot Reader] Elf symbols section not starting with SHT_NULL section");
-
-//       elf_section_header_container sections{begin, end};
-
-//       auto allocated_sections = sections | std::views::filter([](auto const & section) {
-//                                   return section.flags.contains_flags(elf_section_flags::OCCUPIES_MEMORY);
-//                                 });
-
-//       auto const elf_section_with_lowest_physical_address = std::ranges::min_element(
-//           allocated_sections, [](auto const & a, auto const & b) { return a.physical_address < b.physical_address;
-//           });
-
-//       auto const elf_section_with_highest_physical_address =
-//           std::ranges::max_element(allocated_sections, [](auto const & a, auto const & b) {
-//             auto a_physical_address_end = a.physical_address + a.section_size;
-//             auto b_physical_address_end = b.physical_address + b.section_size;
-//             return a_physical_address_end < b_physical_address_end;
-//           });
-
-//       auto const symbol_table_section_count = std::ranges::count_if(sections, [](auto const & section) {
-//         return section.type == elf_section_type::DYNAMIC_SYMBOL_TABLE || section.type ==
-//         elf_section_type::SYMBOL_TABLE;
-//       });
-//       auto const dynamic_section_count = std::ranges::count_if(
-//           sections, [](auto const & section) { return section.type == elf_section_type::DYNAMIC; });
-
-//       exception_handling::assert(
-//           symbol_table_section_count == 1U,
-//           "[Multiboot Reader] ELF Specifications allows only (1) symbol table section, but got more");
-//       exception_handling::assert(
-//           dynamic_section_count <= 1U,
-//           "[Multiboot Reader] ELF Specifications allows only (1) or less dynamic sections, but got more");
-
-//       auto const lowest_elf_section = *elf_section_with_lowest_physical_address;
-//       kernel_start = lowest_elf_section.physical_address;
-
-//       auto const highest_elf_section = *elf_section_with_highest_physical_address;
-//       kernel_end = highest_elf_section.physical_address + highest_elf_section.section_size;
-
-//       return sections;
-//     }
-//   }  // namespace
-
-//   auto read_multiboot2() -> memory_information
-//   {
-//     memory_information mem_info{UINT64_MAX,
-//                                 0U,
-//                                 elf_section_header_container{},
-//                                 boot::multiboot_information_pointer,
-//                                 0U,
-//                                 memory_area_container{}};
-
-//     auto const multiboot_information_pointer = reinterpret_cast<info_header *>(boot::multiboot_information_pointer);
-//     auto const multiboot_tag = &multiboot_information_pointer->tags;
-//     mem_info.multiboot_end = mem_info.multiboot_start + multiboot_information_pointer->total_size;
-
-//     for (auto tag = multiboot_tag; tag->type != tag_type::END; tag = align_to_8_byte_boundary(tag, tag->size))
-//     {
-//       switch (tag->type)
-//       {
-//         case tag_type::ELF_SECTIONS: {
-//           auto const symbol = reinterpret_cast<elf_symbols_section_header *>(tag);
-//           mem_info.sections = process_elf_sections(symbol, mem_info.kernel_start, mem_info.kernel_end);
-//           break;
-//         }
-//         case tag_type::MEMORY_MAP: {
-//           auto const mminfo = reinterpret_cast<memory_map_header *>(tag);
-//           mem_info.areas = process_memory_map(mminfo);
-//           break;
-//         }
-//         default:
-//           // All other cases are not important and can be ignored.
-//           break;
-//       }
-//     }
-//     return mem_info;
-//   }
-// }  // namespace teachos::arch::memory::multiboot
diff --git a/arch/x86_64/pre/src/memory/paging/active_page_table.cpp b/arch/x86_64/pre/src/memory/paging/active_page_table.cpp
deleted file mode 100644
index 930588d..0000000
--- a/arch/x86_64/pre/src/memory/paging/active_page_table.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#include "arch/memory/paging/active_page_table.hpp"
-
-namespace teachos::arch::memory::paging
-{
-  namespace
-  {
-    constexpr paging::virtual_address PAGE_TABLE_LEVEL_4_ADDRESS = 0xffff'ffff'ffff'f000;
-  }
-
-  auto active_page_table::create_or_get() -> active_page_table &
-  {
-    page_table_handle static active_handle{reinterpret_cast<page_table *>(PAGE_TABLE_LEVEL_4_ADDRESS),
-                                           page_table_handle::LEVEL4};
-    active_page_table static active_page{active_handle};
-    return active_page;
-  }
-
-  auto active_page_table::operator[](std::size_t index) -> entry &
-  {
-    return active_handle[index];
-  }
-
-  auto active_page_table::translate_address(virtual_address address) -> std::optional<allocator::physical_address>
-  {
-    auto const offset = address % allocator::PAGE_FRAME_SIZE;
-    auto const page = virtual_page::containing_address(address);
-    auto const frame = translate_page(page);
-
-    if (frame.has_value())
-    {
-      return frame.value().frame_number * allocator::PAGE_FRAME_SIZE + offset;
-    }
-
-    return std::nullopt;
-  }
-
-  auto active_page_table::translate_page(virtual_page page) -> std::optional<allocator::physical_frame>
-  {
-    auto current_handle = active_handle;
-
-    for (auto level = page_table_handle::LEVEL4; level != page_table_handle::LEVEL1; --level)
-    {
-      auto const next_handle = current_handle.next_table(page.get_level_index(level));
-      // If the next table method failed then it is highly likely that it was a huge page and we therefore have to
-      // parse the table differently. Therefore, we attempt to parse it using the method required by huge pages.
-      if (!next_handle.has_value())
-      {
-        return translate_huge_page(page);
-      }
-      current_handle = next_handle.value();
-    }
-
-    auto const level1_index = page.get_level_index(page_table_handle::LEVEL1);
-    auto const level1_entry = current_handle[level1_index];
-    return level1_entry.calculate_pointed_to_frame();
-  }
-
-  auto active_page_table::translate_huge_page(virtual_page page) -> std::optional<allocator::physical_frame>
-  {
-    auto current_handle = active_handle;
-    auto level3_handle = current_handle.next_table(page.get_level_index(page_table_handle::LEVEL4));
-
-    if (!level3_handle.has_value())
-    {
-      return std::nullopt;
-    }
-
-    auto const level3_entry = level3_handle.value()[page.get_level_index(page_table_handle::LEVEL3)];
-    auto const level3_frame = level3_entry.calculate_pointed_to_frame();
-    if (level3_frame.has_value() && level3_entry.contains_flags(entry::HUGE_PAGE))
-    {
-      exception_handling::assert(
-          level3_frame.value().frame_number % (PAGE_TABLE_ENTRY_COUNT * PAGE_TABLE_ENTRY_COUNT) == 0U,
-          "[Page Mapper] Physical address must be 1 GiB aligned");
-      return allocator::physical_frame{level3_frame.value().frame_number +
-                                       page.get_level_index(page_table_handle::LEVEL2) * PAGE_TABLE_ENTRY_COUNT +
-                                       page.get_level_index(page_table_handle::LEVEL1)};
-    }
-
-    auto level2_handle = level3_handle.value().next_table(page.get_level_index(page_table_handle::LEVEL3));
-    if (level2_handle.has_value())
-    {
-      auto const level2_entry = level2_handle.value()[page.get_level_index(page_table_handle::LEVEL2)];
-      auto const level2_frame = level2_entry.calculate_pointed_to_frame();
-      if (level2_frame.has_value() && level2_entry.contains_flags(entry::HUGE_PAGE))
-      {
-        exception_handling::assert(level2_frame.value().frame_number % PAGE_TABLE_ENTRY_COUNT == 0U,
-                                   "[Page Mapper] Physical address must be 2 MiB aligned");
-        return allocator::physical_frame{level2_frame.value().frame_number +
-                                         page.get_level_index(page_table_handle::LEVEL1)};
-      }
-    }
-    return std::nullopt;
-  }
-
-  active_page_table::active_page_table(page_table_handle active_handle)
-      : active_handle(active_handle)
-  {
-    // Nothing to do
-  }
-}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/pre/src/memory/paging/inactive_page_table.cpp b/arch/x86_64/pre/src/memory/paging/inactive_page_table.cpp
deleted file mode 100644
index 4e0610e..0000000
--- a/arch/x86_64/pre/src/memory/paging/inactive_page_table.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-#include "arch/memory/paging/inactive_page_table.hpp"
-
-namespace teachos::arch::memory::paging
-{
-  inactive_page_table::inactive_page_table(allocator::physical_frame frame)
-      : page_table_level_4_frame{frame}
-  {
-    // Nothing to do
-  }
-
-  inactive_page_table::inactive_page_table(allocator::physical_frame frame, active_page_table & active_page_table,
-                                           temporary_page & temporary_page)
-      : page_table_level_4_frame{frame}
-  {
-    auto table = temporary_page.map_table_frame(page_table_level_4_frame, active_page_table);
-    table.zero_entries();
-    table[511].set_entry(page_table_level_4_frame, entry::PRESENT | entry::WRITABLE);
-    temporary_page.unmap_page(active_page_table);
-  }
-}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/pre/src/memory/paging/page_entry.cpp b/arch/x86_64/pre/src/memory/paging/page_entry.cpp
deleted file mode 100644
index ec45068..0000000
--- a/arch/x86_64/pre/src/memory/paging/page_entry.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-#include "arch/memory/paging/page_entry.hpp"
-
-#include "arch/exception_handling/assert.hpp"
-
-namespace teachos::arch::memory::paging
-{
-  namespace
-  {
-    constexpr std::size_t PHYSICAL_ADDRESS_MASK = 0x000f'ffff'ffff'f000;
-  }  // namespace
-
-  entry::entry(uint64_t flags)
-      : flags(flags)
-  {
-    // Nothing to do.
-  }
-
-  entry::entry(multiboot::elf_section_flags elf_flags)
-  {
-    if (elf_flags.contains_flags(multiboot::elf_section_flags::OCCUPIES_MEMORY))
-    {
-      flags |= entry::PRESENT;
-    }
-
-    if (elf_flags.contains_flags(multiboot::elf_section_flags::WRITABLE))
-    {
-      flags |= entry::WRITABLE;
-    }
-
-    if (!elf_flags.contains_flags(multiboot::elf_section_flags::EXECUTABLE_CODE))
-    {
-      flags |= entry::EXECUTING_CODE_FORBIDDEN;
-    }
-  }
-
-  auto entry::is_unused() const -> bool
-  {
-    return flags == 0U;
-  }
-
-  auto entry::set_unused() -> void
-  {
-    flags = 0U;
-  }
-
-  auto entry::set_user_accessible() -> void
-  {
-    flags |= entry::USER_ACCESSIBLE;
-  }
-
-  auto entry::calculate_pointed_to_frame() const -> std::optional<allocator::physical_frame>
-  {
-    if (contains_flags(PRESENT))
-    {
-      auto const address = flags.to_ulong() & PHYSICAL_ADDRESS_MASK;
-      return allocator::physical_frame::containing_address(address);
-    }
-    return std::nullopt;
-  }
-
-  auto entry::contains_flags(std::bitset<64U> other) const -> bool
-  {
-    return (flags & other) == other;
-  }
-
-  auto entry::set_entry(allocator::physical_frame frame, std::bitset<64U> additional_flags) -> void
-  {
-    exception_handling::assert((frame.start_address() & ~PHYSICAL_ADDRESS_MASK) == 0,
-                               "[Paging Entry] Start address is not aligned with page");
-
-    flags = frame.start_address() | additional_flags.to_ulong();
-  }
-
-  auto entry::get_flags() const -> std::bitset<64U>
-  {
-    return flags.to_ulong() & ~PHYSICAL_ADDRESS_MASK;
-  }
-}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/pre/src/memory/paging/page_table.cpp b/arch/x86_64/pre/src/memory/paging/page_table.cpp
deleted file mode 100644
index e79c3e5..0000000
--- a/arch/x86_64/pre/src/memory/paging/page_table.cpp
+++ /dev/null
@@ -1,140 +0,0 @@
-#include "arch/memory/paging/page_table.hpp"
-
-#include <algorithm>
-#include <array>
-#include <memory>
-
-/*
- * This is a linker variable reference. This referenc cannot reside inside a namespace, because in
- * that case the compiler would try to find arch::memory::paging::_end_of_image inside the ELF file.
- */
-extern char _end_of_image;
-
-namespace teachos::arch::memory::paging
-{
-  /**
-   * @brief A Page table containing 512 entries.
-   */
-  struct page_table
-  {
-    auto zero_entries() -> void;
-
-    auto is_empty() const -> bool;
-
-    auto next_table(std::size_t table_index) const -> std::optional<page_table *>;
-
-    auto operator[](std::size_t index) -> entry &;
-
-    auto operator[](std::size_t index) const -> entry const &;
-
-  private:
-    /**
-     * @brief Calculates the address of the next page table level for the given table index.
-     *
-     * @note The next page table address is only valid if the corresponding entry is present and not a huge page.
-     * Meaning we use an index into a Level 4 page table to get the according Level 3 page table address.
-     *
-     * @param table_index Index of this page table in the page table one level higher.
-     * @return An optional of the address of the next page table or null.
-     */
-    auto next_table_address(std::size_t table_index) const -> std::optional<std::size_t>;
-
-    std::array<entry, PAGE_TABLE_ENTRY_COUNT> entries =
-        {};  ///< Entries containing addresses to page tables of a level below or
-             ///< actual virtual addresses for the level 1 page table.
-  };
-
-  auto page_table::zero_entries() -> void
-  {
-    std::ranges::for_each(entries, [](auto & entry) { entry.set_unused(); });
-  }
-
-  auto page_table::is_empty() const -> bool
-  {
-    return std::all_of(entries.begin(), entries.end(), [](entry const & entry) { return entry.is_unused(); });
-  }
-
-  auto page_table::next_table(std::size_t table_index) const -> std::optional<page_table *>
-  {
-    auto const address = next_table_address(table_index);
-    if (address.has_value())
-    {
-      return reinterpret_cast<page_table *>(address.value());
-    }
-    return std::nullopt;
-  }
-
-  auto page_table::operator[](std::size_t index) -> entry &
-  {
-    exception_handling::assert(index < PAGE_TABLE_ENTRY_COUNT, "[Page Table] Index out of bounds");
-    return entries[index];
-  }
-
-  auto page_table::operator[](std::size_t index) const -> entry const &
-  {
-    exception_handling::assert(index < PAGE_TABLE_ENTRY_COUNT, "[Page Table] Index out of bounds");
-    return entries[index];
-  }
-
-  auto page_table::next_table_address(std::size_t table_index) const -> std::optional<std::size_t>
-  {
-    auto const entry = this->operator[](table_index);
-
-    if (entry.contains_flags(entry::PRESENT) && !entry.contains_flags(entry::HUGE_PAGE))
-    {
-      auto const table_address = reinterpret_cast<std::size_t>(this);
-      return ((table_address << 9) | (table_index << 12));
-    }
-    return std::nullopt;
-  }
-
-  page_table_handle::page_table_handle(page_table * table, page_table_handle::level table_level)
-      : table(table)
-      , table_level(table_level)
-  {
-    exception_handling::assert(table != nullptr,
-                               "[Page Table] Attempted to pass nullptr as table to page table table method");
-  }
-
-  auto page_table_handle::zero_entries() -> void
-  {
-    table->zero_entries();
-  }
-
-  auto page_table_handle::is_empty() const -> bool
-  {
-    return table->is_empty();
-  }
-
-  auto page_table_handle::next_table(std::size_t table_index) const -> std::optional<page_table_handle>
-  {
-    exception_handling::assert(table_level != page_table_handle::LEVEL1,
-                               "[Page Table] Attempted to call next_table on level 1 page table");
-    auto const next_table = table->next_table(table_index);
-    if (next_table.has_value())
-    {
-      auto const new_level = static_cast<page_table_handle::level>(table_level - 1);
-      return page_table_handle{next_table.value(), new_level};
-    }
-    return std::nullopt;
-  }
-
-  auto page_table_handle::get_level() const -> page_table_handle::level
-  {
-    return table_level;
-  }
-
-  auto page_table_handle::operator[](std::size_t index) -> entry &
-  {
-    return table->operator[](index);
-  }
-
-  auto operator--(page_table_handle::level & value) -> page_table_handle::level &
-  {
-    exception_handling::assert(value != page_table_handle::LEVEL1,
-                               "[Page table] Attempted to decrement enum to value outside of range");
-    auto new_value = static_cast<std::underlying_type<page_table_handle::level>::type>(value);
-    value = static_cast<page_table_handle::level>(--new_value);
-    return value;
-  }
-}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/pre/src/memory/paging/temporary_page.cpp b/arch/x86_64/pre/src/memory/paging/temporary_page.cpp
deleted file mode 100644
index 8e73523..0000000
--- a/arch/x86_64/pre/src/memory/paging/temporary_page.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include "arch/memory/paging/temporary_page.hpp"
-
-#include "arch/memory/paging/page_entry.hpp"
-
-namespace teachos::arch::memory::paging
-{
-  auto temporary_page::map_table_frame(allocator::physical_frame frame, active_page_table & active_table)
-      -> page_table_handle
-  {
-    page_table_handle handle{reinterpret_cast<page_table *>(map_to_frame(frame, active_table)),
-                             page_table_handle::LEVEL1};
-    return handle;
-  }
-
-  auto temporary_page::map_to_frame(allocator::physical_frame frame, active_page_table & active_table)
-      -> virtual_address
-  {
-    exception_handling::assert(!active_table.translate_page(page).has_value(),
-                               "[Temporary page] Page is already mapped");
-
-    active_table.map_page_to_frame(allocator, page, frame, entry::WRITABLE);
-    return page.start_address();
-  }
-
-  auto temporary_page::unmap_page(active_page_table & active_table) -> void
-  {
-    active_table.unmap_page(allocator, page);
-  }
-}  // namespace teachos::arch::memory::paging
diff --git a/arch/x86_64/pre/src/memory/paging/virtual_page.cpp b/arch/x86_64/pre/src/memory/paging/virtual_page.cpp
deleted file mode 100644
index 8d34918..0000000
--- a/arch/x86_64/pre/src/memory/paging/virtual_page.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-#include "arch/memory/paging/virtual_page.hpp"
-
-#include "arch/exception_handling/assert.hpp"
-
-namespace teachos::arch::memory::paging
-{
-  auto virtual_page::containing_address(virtual_address address) -> virtual_page
-  {
-    exception_handling::assert(address < 0x0000'8000'0000'0000 || address >= 0xffff'8000'0000'0000,
-                               "[Virtual Page] Attempted to create virtual page from invalid address");
-    return virtual_page{address / allocator::PAGE_FRAME_SIZE};
-  }
-
-  auto virtual_page::start_address() const -> virtual_address
-  {
-    return page_number * allocator::PAGE_FRAME_SIZE;
-  }
-
-  auto virtual_page::get_level_index(page_table_handle::level level) const -> size_t
-  {
-    return (page_number >> (level * 9U)) & 0x1FF;
-  }
-
-  auto virtual_page::operator++(int) -> virtual_page
-  {
-    virtual_page const old_value = *this;
-    ++page_number;
-    return old_value;
-  }
-
-  auto virtual_page::operator++() -> virtual_page &
-  {
-    ++page_number;
-    return *this;
-  }
-}  // namespace teachos::arch::memory::paging