acpi: introduce VLA table

18 files changed, 283 insertions, 325 deletions

diff --git a/kapi/include/kapi/acpi.hpp b/kapi/include/kapi/acpi.hpp
index 2835496..b607ee0 100644
--- a/kapi/include/kapi/acpi.hpp
+++ b/kapi/include/kapi/acpi.hpp
@@ -23,7 +23,7 @@ namespace kapi::acpi
   //!
   //! @param signature The signature of the table to get.
   //! @return A pointer to the table if found, nullptr otherwise.
-  auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::sdt const>;
+  auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::table_header const>;
 
   //! Get a type-cast pointer to an ACPI table by its signature.
   //!
diff --git a/kernel/include/kernel/acpi/manager.hpp b/kernel/include/kernel/acpi/manager.hpp
index 420b44a..860d609 100644
--- a/kernel/include/kernel/acpi/manager.hpp
+++ b/kernel/include/kernel/acpi/manager.hpp
@@ -18,12 +18,12 @@ namespace kernel::acpi
 
     auto load_tables() -> bool;
 
-    auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::sdt const>;
+    auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::table_header const>;
 
   private:
     ::acpi::rsdp const * m_sdp{};
-    ::acpi::sdt const * m_rsdt{};
-    kstd::flat_map<std::string_view, ::acpi::sdt const *> m_tables{};
+    ::acpi::table_header const * m_rsdt{};
+    kstd::flat_map<std::string_view, ::acpi::table_header const *> m_tables{};
     bool m_extended{};
   };
 
diff --git a/kernel/kapi/acpi.cpp b/kernel/kapi/acpi.cpp
index df2bf05..5a2f227 100644
--- a/kernel/kapi/acpi.cpp
+++ b/kernel/kapi/acpi.cpp
@@ -32,7 +32,7 @@ namespace kapi::acpi
     return manager->load_tables();
   }
 
-  auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::sdt const>
+  auto get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::table_header const>
   {
     return manager->get_table(signature);
   }
diff --git a/kernel/src/acpi/manager.cpp b/kernel/src/acpi/manager.cpp
index 501ce92..41469c2 100644
--- a/kernel/src/acpi/manager.cpp
+++ b/kernel/src/acpi/manager.cpp
@@ -32,7 +32,7 @@ namespace kernel::acpi
       }
       auto physical_extended_table_address = kapi::memory::physical_address{xsdp->table_address()};
       auto linear_extended_table_address = kapi::memory::hhdm_to_linear(physical_extended_table_address);
-      m_rsdt = static_cast<::acpi::sdt const *>(linear_extended_table_address);
+      m_rsdt = static_cast<::acpi::table_header const *>(linear_extended_table_address);
       m_extended = true;
     }
     else
@@ -43,7 +43,7 @@ namespace kernel::acpi
       }
       auto physical_root_table_address = kapi::memory::physical_address{m_sdp->table_address()};
       auto linear_root_table_address = kapi::memory::hhdm_to_linear(physical_root_table_address);
-      m_rsdt = static_cast<::acpi::sdt const *>(linear_root_table_address);
+      m_rsdt = static_cast<::acpi::table_header const *>(linear_root_table_address);
     }
   }
 
@@ -55,8 +55,8 @@ namespace kernel::acpi
     }
 
     auto entry_size = m_extended ? sizeof(std::uint64_t) : sizeof(std::uint32_t);
-    auto entry_count = (m_rsdt->length().value - sizeof(::acpi::sdt)) / entry_size;
-    auto entries_base = reinterpret_cast<std::byte const *>(m_rsdt) + sizeof(::acpi::sdt);
+    auto entry_count = (m_rsdt->length().value - sizeof(::acpi::table_header)) / entry_size;
+    auto entries_base = reinterpret_cast<std::byte const *>(m_rsdt) + sizeof(::acpi::table_header);
 
     for (std::size_t i = 0; i < entry_count; ++i)
     {
@@ -74,7 +74,7 @@ namespace kernel::acpi
       }
 
       auto linear_table_address = kapi::memory::hhdm_to_linear(physical_table_address);
-      auto table = static_cast<::acpi::sdt const *>(linear_table_address);
+      auto table = static_cast<::acpi::table_header const *>(linear_table_address);
 
       if (!::acpi::validate_checksum({reinterpret_cast<std::byte const *>(table), table->length().value}))
       {
@@ -90,7 +90,7 @@ namespace kernel::acpi
     return !m_tables.empty();
   }
 
-  auto manager::get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::sdt const>
+  auto manager::get_table(std::string_view signature) -> kstd::observer_ptr<::acpi::table_header const>
   {
     if (m_tables.contains(signature))
     {
diff --git a/libs/acpi/CMakeLists.txt b/libs/acpi/CMakeLists.txt
index f850fe4..97c351b 100644
--- a/libs/acpi/CMakeLists.txt
+++ b/libs/acpi/CMakeLists.txt
@@ -19,12 +19,10 @@ file(GLOB_RECURSE ACPI_HEADERS
 )
 
 target_sources("acpi" PRIVATE
-  "acpi/common/basic_table.cpp"
   "acpi/common/checksum.cpp"
   "acpi/common/table_header.cpp"
   "acpi/madt.cpp"
   "acpi/pointers.cpp"
-  "acpi/sdt.cpp"
 )
 
 target_sources("acpi" PUBLIC
@@ -61,7 +59,6 @@ if(NOT CMAKE_CROSSCOMPILING)
   set_source_files_properties("test_data/tables.S" PROPERTIES OBJECT_DEPENDS "${GENERATED_TABLE_BLOBS}")
 
   add_executable("acpi_tests"
-    "acpi/common/basic_table.test.cpp"
     "acpi/common/table_header.test.cpp"
     "acpi/madt.test.cpp"
     "acpi/pointers.test.cpp"
diff --git a/libs/acpi/acpi/acpi.hpp b/libs/acpi/acpi/acpi.hpp
index 47050f2..2962c7a 100644
--- a/libs/acpi/acpi/acpi.hpp
+++ b/libs/acpi/acpi/acpi.hpp
@@ -1,10 +1,10 @@
 #ifndef ACPI_ACPI_HPP
 #define ACPI_ACPI_HPP
 
-#include <acpi/common/checksum.hpp>  // IWYU pragma: export
-#include <acpi/madt.hpp>             // IWYU pragma: export
-#include <acpi/pointers.hpp>         // IWYU pragma: export
-#include <acpi/sdt.hpp>              // IWYU pragma: export
-#include <acpi/table_type.hpp>       // IWYU pragma: export
+#include <acpi/common/checksum.hpp>         // IWYU pragma: export
+#include <acpi/common/table_signature.hpp>  // IWYU pragma: export
+#include <acpi/common/table_type.hpp>       // IWYU pragma: export
+#include <acpi/madt.hpp>                    // IWYU pragma: export
+#include <acpi/pointers.hpp>                // IWYU pragma: export
 
 #endif
diff --git a/libs/acpi/acpi/common/basic_table.cpp b/libs/acpi/acpi/common/basic_table.cpp
deleted file mode 100644
index 5cec91a..0000000
--- a/libs/acpi/acpi/common/basic_table.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <acpi/common/basic_table.hpp>
-#include <acpi/common/checksum.hpp>
-#include <acpi/common/table_header.hpp>
-
-#include <cstddef>
-#include <span>
-
-namespace acpi
-{
-
-  auto basic_table::validate_checksum() const noexcept -> bool
-  {
-    return acpi::validate_checksum({reinterpret_cast<std::byte const *>(this), m_header.length().value});
-  }
-
-  auto basic_table::as_span() const noexcept -> std::span<std::byte const>
-  {
-    return {reinterpret_cast<std::byte const *>(this), m_header.length().value};
-  }
-
-  auto basic_table::header() const noexcept -> table_header const &
-  {
-    return m_header;
-  }
-
-}  // namespace acpi
\ No newline at end of file
diff --git a/libs/acpi/acpi/common/basic_table.hpp b/libs/acpi/acpi/common/basic_table.hpp
index 43bf533..b0ead96 100644
--- a/libs/acpi/acpi/common/basic_table.hpp
+++ b/libs/acpi/acpi/common/basic_table.hpp
@@ -1,21 +1,49 @@
 #ifndef ACPI_COMMON_BASIC_TABLE_HPP
 #define ACPI_COMMON_BASIC_TABLE_HPP
 
+#include <acpi/common/checksum.hpp>
 #include <acpi/common/table_header.hpp>
+#include <acpi/common/table_signature.hpp>
 
 #include <cstddef>
 #include <span>
+#include <string_view>
 
 namespace acpi
 {
 
+  template<typename TableType>
   struct basic_table
   {
-    [[nodiscard]] auto validate_checksum() const noexcept -> bool;
-
-    [[nodiscard]] auto as_span() const noexcept -> std::span<std::byte const>;
-
-    [[nodiscard]] auto header() const noexcept -> table_header const &;
+    [[nodiscard]] auto validate_checksum() const noexcept -> bool
+    {
+      return acpi::validate_checksum({reinterpret_cast<std::byte const *>(this), m_header.length().value});
+    }
+
+    [[nodiscard]] auto as_span() const noexcept -> std::span<std::byte const>
+    {
+      return {reinterpret_cast<std::byte const *>(this), m_header.length().value};
+    }
+
+    [[nodiscard]] auto header() const noexcept -> table_header const &
+    {
+      return m_header;
+    }
+
+    [[nodiscard]] auto length() const noexcept -> std::size_t
+    {
+      return m_header.length().value;
+    }
+
+    [[nodiscard]] auto signature() const noexcept -> std::string_view
+    {
+      return m_header.signature();
+    }
+
+    [[nodiscard]] auto validate() const noexcept -> bool
+    {
+      return signature() == table_signature_v<TableType> && validate_checksum();
+    }
 
   private:
     table_header m_header;
diff --git a/libs/acpi/acpi/common/basic_table.test.cpp b/libs/acpi/acpi/common/basic_table.test.cpp
deleted file mode 100644
index e292b9f..0000000
--- a/libs/acpi/acpi/common/basic_table.test.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include <acpi/common/basic_table.hpp>
-#include <catch2/catch_test_macros.hpp>
-#include <test_data/tables.hpp>
-
-SCENARIO("Basic table functions", "[basic_table]")
-{
-  GIVEN("A valid compiled table header")
-  {
-    auto data = acpi::test_data::tables::table_header();
-
-    WHEN("parsing the table")
-    {
-      auto table = reinterpret_cast<acpi::basic_table const *>(data.data());
-
-      THEN("the checksum is valid")
-      {
-        REQUIRE(table->validate_checksum());
-      }
-    }
-  }
-}
diff --git a/libs/acpi/acpi/common/table_header.hpp b/libs/acpi/acpi/common/table_header.hpp
index 529da81..471fed8 100644
--- a/libs/acpi/acpi/common/table_header.hpp
+++ b/libs/acpi/acpi/common/table_header.hpp
@@ -1,6 +1,8 @@
 #ifndef ACPI_COMMON_TABLE_HEADER_HPP
 #define ACPI_COMMON_TABLE_HEADER_HPP
 
+// IWYU pragma: private, include <acpi/acpi.hpp>
+
 #include <kstd/units>
 
 #include <array>
diff --git a/libs/acpi/acpi/common/table_signature.hpp b/libs/acpi/acpi/common/table_signature.hpp
new file mode 100644
index 0000000..f0c2d7a
--- /dev/null
+++ b/libs/acpi/acpi/common/table_signature.hpp
@@ -0,0 +1,17 @@
+#ifndef ACPI_COMMON_TABLE_SIGNATURE_HPP
+#define ACPI_COMMON_TABLE_SIGNATURE_HPP
+
+// IWYU pragma: private, include <acpi/acpi.hpp>
+
+namespace acpi
+{
+
+  template<typename TableType>
+  struct table_signature;
+
+  template<typename TableType>
+  constexpr auto table_signature_v = table_signature<TableType>::value;
+
+}  // namespace acpi
+
+#endif
diff --git a/libs/acpi/acpi/table_type.hpp b/libs/acpi/acpi/common/table_type.hpp
index 7fdd7e3..bc427c7 100644
--- a/libs/acpi/acpi/table_type.hpp
+++ b/libs/acpi/acpi/common/table_type.hpp
@@ -1,5 +1,5 @@
-#ifndef ACPI_TABLE_TYPE_HPP
-#define ACPI_TABLE_TYPE_HPP
+#ifndef ACPI_COMMON_TABLE_TYPE_HPP
+#define ACPI_COMMON_TABLE_TYPE_HPP
 
 // IWYU pragma: private, include <acpi/acpi.hpp>
 
diff --git a/libs/acpi/acpi/common/vla_table.hpp b/libs/acpi/acpi/common/vla_table.hpp
new file mode 100644
index 0000000..450209c
--- /dev/null
+++ b/libs/acpi/acpi/common/vla_table.hpp
@@ -0,0 +1,115 @@
+#ifndef ACPI_COMMON_VLA_TABLE_HPP
+#define ACPI_COMMON_VLA_TABLE_HPP
+
+#include <acpi/common/basic_table.hpp>
+
+#include <cstddef>
+#include <iterator>
+
+namespace acpi
+{
+
+  template<typename EntryType>
+  struct vla_table_iterator
+  {
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = EntryType;
+    using pointer = value_type *;
+    using reference = value_type &;
+    using difference_type = std::ptrdiff_t;
+
+    constexpr vla_table_iterator() noexcept = default;
+
+    constexpr vla_table_iterator(pointer entry, pointer limit) noexcept
+        : m_entry{entry}
+        , m_limit{limit}
+    {}
+
+    constexpr auto operator++() noexcept -> vla_table_iterator &
+    {
+      auto decayed = std::bit_cast<std::byte *>(m_entry);
+      decayed += m_entry->length();
+      m_entry = std::bit_cast<pointer>(decayed);
+      return *this;
+    }
+
+    constexpr auto operator++(int) noexcept -> vla_table_iterator
+    {
+      auto copy = *this;
+      ++*this;
+      return copy;
+    }
+
+    constexpr auto operator*() const noexcept -> reference
+    {
+      return *m_entry;
+    }
+
+    constexpr auto operator->() const noexcept -> pointer
+    {
+      return m_entry;
+    }
+
+    constexpr auto operator==(vla_table_iterator const & other) const noexcept -> bool
+    {
+      return m_entry == other.m_entry || (is_end() && other.is_end());
+    }
+
+  private:
+    [[nodiscard]] constexpr auto is_end() const noexcept -> bool
+    {
+      return m_entry == m_limit;
+    }
+
+    pointer m_entry{};
+    pointer m_limit{};
+  };
+
+  template<typename EntryType, typename TableType>
+  struct vla_table : basic_table<TableType>
+  {
+    using entry_type = EntryType;
+    using iterator = vla_table_iterator<EntryType>;
+    using const_iterator = vla_table_iterator<EntryType const>;
+
+    [[nodiscard]] auto begin() noexcept -> iterator
+    {
+      auto base = std::bit_cast<std::byte *>(this);
+      base += sizeof(TableType);
+      auto limit = std::bit_cast<std::byte *>(this);
+      limit += this->length();
+      return iterator{std::bit_cast<entry_type *>(base), std::bit_cast<entry_type *>(limit)};
+    }
+
+    [[nodiscard]] auto end() noexcept -> iterator
+    {
+      return iterator{};
+    }
+
+    [[nodiscard]] auto begin() const noexcept -> const_iterator
+    {
+      auto base = std::bit_cast<std::byte *>(this);
+      base += sizeof(TableType);
+      auto limit = std::bit_cast<std::byte *>(this);
+      limit += this->length();
+      return const_iterator{std::bit_cast<entry_type const *>(base), std::bit_cast<entry_type const *>(limit)};
+    }
+
+    [[nodiscard]] auto end() const noexcept -> const_iterator
+    {
+      return const_iterator{};
+    }
+
+    [[nodiscard]] auto cbegin() const noexcept -> const_iterator
+    {
+      return begin();
+    }
+
+    [[nodiscard]] auto cend() const noexcept -> const_iterator
+    {
+      return end();
+    }
+  };
+}  // namespace acpi
+
+#endif
\ No newline at end of file
diff --git a/libs/acpi/acpi/madt.cpp b/libs/acpi/acpi/madt.cpp
index 6a62f07..c6830ad 100644
--- a/libs/acpi/acpi/madt.cpp
+++ b/libs/acpi/acpi/madt.cpp
@@ -1,74 +1,112 @@
-#include <acpi/acpi.hpp>
+#include <kstd/cstring>
+
 #include <acpi/madt.hpp>
 
+#include <bit>
 #include <cstddef>
 #include <cstdint>
+#include <span>
 
 namespace acpi
 {
 
+  struct madt_data
+  {
+    std::uint32_t local_interrupt_controller_address;
+    std::uint32_t flags;
+  };
+
+  static_assert(sizeof(madt_data) == 8);
+
   auto madt::local_interrupt_controller_address() const noexcept -> std::uintptr_t
   {
-    return static_cast<std::uintptr_t>(m_local_interrupt_controller_address);
+    using type = decltype(madt_data::local_interrupt_controller_address);
+
+    constexpr auto size = sizeof(type);
+    constexpr auto offset = offsetof(madt_data, local_interrupt_controller_address);
+
+    auto const data = std::span<std::byte const, size>{m_data.data() + offset, size};
+    auto value = type{};
+
+    kstd::libc::memcpy(&value, data.data(), size);
+
+    return value;
   }
 
   auto madt::flags() const noexcept -> std::uint32_t
   {
-    return m_flags;
+    using type = decltype(madt_data::flags);
+
+    constexpr auto size = sizeof(type);
+    constexpr auto offset = offsetof(madt_data, flags);
+
+    auto const data = std::span<std::byte const, size>{m_data.data() + offset, size};
+    auto value = type{};
+
+    kstd::libc::memcpy(&value, data.data(), size);
+
+    return value;
   }
 
-  auto madt::validate() const noexcept -> bool
+  struct madt_entry_data
   {
-    return signature() == madt_table_signature && sdt::validate();
-  }
+    std::uint8_t type;
+    std::uint8_t length;
+  };
+
+  static_assert(sizeof(madt_entry_data) == 2);
 
   auto madt_entry::type() const noexcept -> enum type
   {
-    return static_cast<enum type>(m_type);
+    constexpr auto field_offset = offsetof(madt_entry_data, type);
+
+    return std::bit_cast<enum type>(*(m_data.data() + field_offset));
   }
 
   auto madt_entry::length() const noexcept -> std::size_t
   {
-    return m_length;
-  }
+    constexpr auto field_offset = offsetof(madt_entry_data, length);
 
-  auto processor_local_apic::apic_id() const noexcept -> std::uint8_t
-  {
-    return m_apic_id;
+    return static_cast<std::size_t>(*(m_data.data() + field_offset));
   }
 
-  auto processor_local_apic::active_flags() const noexcept -> flags
+  struct [[gnu::packed]] processor_local_apic_entry_data
   {
-    return static_cast<flags>(m_flags);
-  }
+    std::uint8_t apic_id;
+    std::uint8_t processor_id;
+    std::uint32_t flags;
+  };
 
-  auto processor_local_apic::processor_id() const noexcept -> std::uint32_t
-  {
-    return m_processor_id;
-  }
+  static_assert(sizeof(processor_local_apic_entry_data) == 6);
 
-  auto madt::begin() const noexcept -> iterator
+  auto processor_local_apic_entry::id() const noexcept -> std::uint8_t
   {
-    auto base = reinterpret_cast<std::byte const *>(this);
-    base += sizeof(madt);
-    auto limit = reinterpret_cast<std::byte const *>(this);
-    limit += length().value;
-    return iterator{reinterpret_cast<madt_entry const *>(base), reinterpret_cast<madt_entry const *>(limit)};
-  }
+    constexpr auto field_offset = offsetof(processor_local_apic_entry_data, apic_id);
 
-  auto madt::cbegin() const noexcept -> iterator
-  {
-    return begin();
+    return static_cast<std::uint8_t>(*(m_data.data() + field_offset));
   }
 
-  auto madt::end() const noexcept -> iterator
+  auto processor_local_apic_entry::flags() const noexcept -> enum flags
   {
-    return {};
+    using type = decltype(processor_local_apic_entry_data::flags);
+    static_assert(sizeof(type) == sizeof(enum flags));
+
+    constexpr auto size = sizeof(type);
+    constexpr auto offset = offsetof(processor_local_apic_entry_data, flags);
+
+    auto const data = std::span<std::byte const, size>{m_data.data() + offset, size};
+    auto value = type{};
+
+    kstd::libc::memcpy(&value, data.data(), size);
+
+    return static_cast<enum flags>(value);
   }
 
-  auto madt::cend() const noexcept -> iterator
+  auto processor_local_apic_entry::processor_id() const noexcept -> std::uint32_t
   {
-    return end();
+    constexpr auto field_offset = offsetof(processor_local_apic_entry_data, processor_id);
+
+    return static_cast<std::uint32_t>(*(m_data.data() + field_offset));
   }
 
 }  // namespace acpi
diff --git a/libs/acpi/acpi/madt.hpp b/libs/acpi/acpi/madt.hpp
index 8b75f58..8307826 100644
--- a/libs/acpi/acpi/madt.hpp
+++ b/libs/acpi/acpi/madt.hpp
@@ -7,9 +7,11 @@
 #include <kstd/os/error.hpp>
 #include <kstd/units>
 
-#include <acpi/sdt.hpp>
-#include <acpi/table_type.hpp>
+#include <acpi/common/table_signature.hpp>
+#include <acpi/common/table_type.hpp>
+#include <acpi/common/vla_table.hpp>
 
+#include <array>
 #include <cstddef>
 #include <cstdint>
 #include <ranges>
@@ -18,7 +20,19 @@
 namespace acpi
 {
 
-  struct [[gnu::packed]] madt_entry
+  template<>
+  struct table_signature<struct madt>
+  {
+    constexpr char static const value[] = "APIC";  // NOLINT
+  };
+
+  template<>
+  struct table_type<table_signature_v<struct madt>>
+  {
+    using type = struct madt;
+  };
+
+  struct madt_entry
   {
     //! The type of an MADT entry.
     enum struct type : std::uint8_t
@@ -53,26 +67,16 @@ namespace acpi
     }
 
   private:
-    std::uint8_t m_type;
-    std::uint8_t m_length;
+    std::array<std::byte, 2> m_data{};
   };
 
   //! The Multiple APIC Description Table (MADT)
-  struct [[gnu::packed]] madt : sdt
+  struct madt : vla_table<madt_entry, madt>
   {
-    using iterator = sdt_iterator<madt_entry const>;
-    using const_iterator = iterator;
-
     //! Get the physical address of the local interrupt controllers described by this entry.
     [[nodiscard]] auto local_interrupt_controller_address() const noexcept -> std::uintptr_t;
 
     [[nodiscard]] auto flags() const noexcept -> std::uint32_t;
-    [[nodiscard]] auto validate() const noexcept -> bool;
-
-    [[nodiscard]] auto begin() const noexcept -> iterator;
-    [[nodiscard]] auto cbegin() const noexcept -> iterator;
-    [[nodiscard]] auto end() const noexcept -> iterator;
-    [[nodiscard]] auto cend() const noexcept -> iterator;
 
     template<typename EntryType>
     [[nodiscard]] auto only() const noexcept
@@ -82,11 +86,10 @@ namespace acpi
     }
 
   private:
-    std::uint32_t m_local_interrupt_controller_address;
-    std::uint32_t m_flags;
+    std::array<std::byte, 8> m_data{};
   };
 
-  struct [[gnu::packed]] processor_local_apic : madt_entry
+  struct processor_local_apic_entry : madt_entry
   {
     constexpr auto static this_type = type::processor_local_apic;
 
@@ -96,28 +99,18 @@ namespace acpi
       online_capable = 2,
     };
 
-    [[nodiscard]] auto apic_id() const noexcept -> std::uint8_t;
-    [[nodiscard]] auto active_flags() const noexcept -> flags;
+    [[nodiscard]] auto id() const noexcept -> std::uint8_t;
+    [[nodiscard]] auto flags() const noexcept -> flags;
     [[nodiscard]] auto processor_id() const noexcept -> std::uint32_t;
 
   private:
-    std::uint8_t m_processor_id;
-    std::uint8_t m_apic_id;
-    std::uint32_t m_flags;
-  };
-
-  constexpr char const madt_table_signature[] = "APIC";  // NOLINT
-
-  template<>
-  struct table_type<madt_table_signature>
-  {
-    using type = madt;
+    std::array<std::byte, 6> m_data{};
   };
 
 }  // namespace acpi
 
 template<>
-struct kstd::ext::is_bitfield_enum<acpi::processor_local_apic::flags> : std::true_type
+struct kstd::ext::is_bitfield_enum<enum acpi::processor_local_apic_entry::flags> : std::true_type
 {
 };
 
diff --git a/libs/acpi/acpi/madt.test.cpp b/libs/acpi/acpi/madt.test.cpp
index 8926192..899a377 100644
--- a/libs/acpi/acpi/madt.test.cpp
+++ b/libs/acpi/acpi/madt.test.cpp
@@ -38,7 +38,7 @@ SCENARIO("MADT parsing", "[madt]")
 
       THEN("the length is sizeof(madt) + sizeof(processor_local_apic)")
       {
-        REQUIRE(madt->length() == kstd::type_size<acpi::madt> + kstd::type_size<acpi::processor_local_apic>);
+        REQUIRE(madt->length() == sizeof(acpi::madt) + sizeof(acpi::processor_local_apic_entry));
       }
 
       THEN("the first entry has type processor_local_apic")
@@ -48,7 +48,7 @@ SCENARIO("MADT parsing", "[madt]")
 
       THEN("`only` can be used to get a view of all processor_local_apic entries")
       {
-        REQUIRE(std::ranges::distance(madt->only<acpi::processor_local_apic>()) == 1);
+        REQUIRE(std::ranges::distance(madt->only<acpi::processor_local_apic_entry>()) == 1);
       }
     }
   }
diff --git a/libs/acpi/acpi/sdt.cpp b/libs/acpi/acpi/sdt.cpp
deleted file mode 100644
index 6c6cb47..0000000
--- a/libs/acpi/acpi/sdt.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <kstd/units>
-
-#include <acpi/acpi.hpp>
-#include <acpi/sdt.hpp>
-
-#include <cstddef>
-#include <cstdint>
-#include <string_view>
-
-namespace acpi
-{
-
-  auto sdt::creator_revision() const noexcept -> std::uint32_t
-  {
-    return m_creator_revision;
-  }
-
-  auto sdt::creator_id() const noexcept -> std::uint32_t
-  {
-    return m_creator_id;
-  }
-
-  auto sdt::length() const noexcept -> kstd::units::bytes
-  {
-    return kstd::units::bytes{m_length};
-  }
-
-  auto sdt::oem_id() const noexcept -> std::string_view
-  {
-    return {m_oem_id.data(), m_oem_id.size()};
-  }
-
-  auto sdt::oem_revision() const noexcept -> std::uint32_t
-  {
-    return m_oem_revision;
-  }
-
-  auto sdt::oem_table_id() const noexcept -> std::string_view
-  {
-    return {m_oem_table_id.data(), m_oem_table_id.size()};
-  }
-
-  auto sdt::revision() const noexcept -> std::uint8_t
-  {
-    return m_revision;
-  }
-
-  auto sdt::signature() const noexcept -> std::string_view
-  {
-    return {m_signature.data(), m_signature.size()};
-  }
-
-  auto sdt::validate() const noexcept -> bool
-  {
-    return acpi::validate_checksum({reinterpret_cast<std::byte const *>(this), length().value});
-  }
-
-}  // namespace acpi
diff --git a/libs/acpi/acpi/sdt.hpp b/libs/acpi/acpi/sdt.hpp
deleted file mode 100644
index 72b3896..0000000
--- a/libs/acpi/acpi/sdt.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-#ifndef ACPI_SDT_HPP
-#define ACPI_SDT_HPP
-
-// IWYU pragma: private, include <acpi/acpi.hpp>
-
-#include <kstd/units>
-
-#include <acpi/table_type.hpp>
-
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <string_view>
-
-namespace acpi
-{
-
-  template<typename EntryType>
-  struct sdt_iterator
-  {
-    using iterator_category = std::forward_iterator_tag;
-    using value_type = EntryType;
-    using pointer = value_type *;
-    using reference = value_type &;
-    using difference_type = std::ptrdiff_t;
-
-    constexpr sdt_iterator() noexcept = default;
-
-    constexpr sdt_iterator(pointer entry, pointer limit) noexcept
-        : m_entry{entry}
-        , m_limit{limit}
-    {}
-
-    constexpr auto operator++() noexcept -> sdt_iterator &
-    {
-      auto decayed = std::bit_cast<std::byte *>(m_entry);
-      decayed += m_entry->length();
-      m_entry = std::bit_cast<pointer>(decayed);
-      return *this;
-    }
-
-    constexpr auto operator++(int) noexcept -> sdt_iterator
-    {
-      auto copy = *this;
-      ++*this;
-      return copy;
-    }
-
-    constexpr auto operator*() const noexcept -> reference
-    {
-      return *m_entry;
-    }
-
-    constexpr auto operator->() const noexcept -> pointer
-    {
-      return m_entry;
-    }
-
-    constexpr auto operator==(sdt_iterator const & other) const noexcept -> bool
-    {
-      return m_entry == other.m_entry || (is_end() && other.is_end());
-    }
-
-  private:
-    [[nodiscard]] constexpr auto is_end() const noexcept -> bool
-    {
-      return m_entry == m_limit;
-    }
-
-    pointer m_entry{};
-    pointer m_limit{};
-  };
-
-  //! The common base of all System Description Tables.
-  struct [[gnu::packed]] sdt
-  {
-    //! Get the revision of the utility used to create this table.
-    [[nodiscard]] auto creator_revision() const noexcept -> std::uint32_t;
-
-    //! Get the vendor ID of the utility used to create this table.
-    [[nodiscard]] auto creator_id() const noexcept -> std::uint32_t;
-
-    //! Get the length of the entire table, including this header.
-    [[nodiscard]] auto length() const noexcept -> kstd::units::bytes;
-
-    //! Get the ID of the OEM.
-    [[nodiscard]] auto oem_id() const noexcept -> std::string_view;
-
-    //! Get the OEMs revision number of this table.
-    [[nodiscard]] auto oem_revision() const noexcept -> std::uint32_t;
-
-    //! Get the OEMs ID of this table.
-    [[nodiscard]] auto oem_table_id() const noexcept -> std::string_view;
-
-    //! Get the revision number of the structure of this table.
-    [[nodiscard]] auto revision() const noexcept -> std::uint8_t;
-
-    //! Get the signature of this table.
-    [[nodiscard]] auto signature() const noexcept -> std::string_view;
-
-    //! Valide this table's checksum
-    [[nodiscard]] auto validate() const noexcept -> bool;
-
-  private:
-    std::array<char, 4> m_signature;
-    std::uint32_t m_length;
-    std::uint8_t m_revision;
-    [[maybe_unused]] std::uint8_t m_checksum;
-    std::array<char, 6> m_oem_id;
-    std::array<char, 8> m_oem_table_id;
-    std::uint32_t m_oem_revision;
-    std::uint32_t m_creator_id;
-    std::uint32_t m_creator_revision;
-  };
-
-  constexpr char const rsdt_table_signature[] = "RSDT";  // NOLINT
-
-  template<>
-  struct table_type<rsdt_table_signature>
-  {
-    using type = sdt;
-  };
-
-}  // namespace acpi
-
-#endif