ref: update formatting

.clang-format

@@ -0,0 +1,8 @@
+BasedOnStyle: LLVM
+IndentWidth: 4
+ColumnLimit: 120
+PointerAlignment: Left
+AccessModifierOffset: -4
+AllowShortFunctionsOnASingleLine: Inline
+BreakTemplateDeclarations: Yes
+SpaceAfterTemplateKeyword: false

kernel/include/init/acpi.h

@@ -1,15 +1,15 @@
 #pragma once
 
-#include "util/number.h"
 #include "memory/pointer.h"
+#include "util/number.h"
 
 namespace acpi {
 
 constexpr uint32_t fold_signature(const char (&text)[5]) {
-    return static_cast<uint32_t>(static_cast<uint8_t>(text[0]))
+    return static_cast<uint32_t>(static_cast<uint8_t>(text[0])) |
-         | static_cast<uint32_t>(static_cast<uint8_t>(text[1])) << 8
+           static_cast<uint32_t>(static_cast<uint8_t>(text[1])) << 8 |
-         | static_cast<uint32_t>(static_cast<uint8_t>(text[2])) << 16
+           static_cast<uint32_t>(static_cast<uint8_t>(text[2])) << 16 |
-         | static_cast<uint32_t>(static_cast<uint8_t>(text[3])) << 24;
+           static_cast<uint32_t>(static_cast<uint8_t>(text[3])) << 24;
 }
 
 enum class signature : uint32_t {
@@ -90,7 +90,8 @@ private:
 
         switch (static_cast<signature>(header->signature)) {
             ACPI_DISPATCH(madt, madt_t)
-            default: break;
+        default:
+            break;
         }
 
 #undef ACPI_DISPATCH
@@ -100,9 +101,7 @@ private:
         }
     }
 
-    bool uses_xsdt() {
+    bool uses_xsdt() { return physical.access<rsdp_t>()->revision >= 2; }
-        return physical.access<rsdp_t>()->revision >= 2;
-    }
 
     paddr_t root_table() {
         auto rsdp = physical.access<rsdp_t>();

kernel/include/init/apic.h

@@ -134,14 +134,12 @@ struct madt_local_apic_address_override_t {
 static_assert(sizeof(madt_local_apic_address_override_t) == 12);
 
 struct Madt {
-  explicit Madt(paddr_t madt_physical)
+    explicit Madt(paddr_t madt_physical) : table(madt_physical.access<madt_t>()) {}
-      : table(madt_physical.access<madt_t>()) {}
     explicit Madt(const madt_t* madt_table) : table(madt_table) {}
 
     paddr_t local_apic_address() {
         uint64_t address = table->local_apic_address;
-    for_each_entry(
+        for_each_entry([&](const madt_local_apic_address_override_t* override_entry) {
-        [&](const madt_local_apic_address_override_t *override_entry) {
             address = override_entry->local_apic_address;
         });
         return paddr_t{address};
@@ -149,10 +147,10 @@ struct Madt {
 
     bool has_legacy_pic() { return table->flags.dual_8259_present != 0; }
 
-  template <typename Fn> void for_each_entry(Fn &&callback) {
+    template<typename Fn>
+    void for_each_entry(Fn&& callback) {
         auto ptr = table->entries;
-    const auto end =
+        const auto end = reinterpret_cast<const uint8_t*>(table) + table->header.length;
-        reinterpret_cast<const uint8_t *>(table) + table->header.length;
         while (ptr < end) {
             auto entry = reinterpret_cast<const madt_entry_t*>(ptr);
             if (entry->length < sizeof(madt_entry_t)) {
@@ -178,8 +176,7 @@ private:
             MADT_DISPATCH(interrupt_source_override, madt_interrupt_source_override_t)
             MADT_DISPATCH(nmi_source, madt_nmi_source_t)
             MADT_DISPATCH(local_apic_nmi, madt_local_apic_nmi_t)
-      MADT_DISPATCH(local_apic_address_override,
+            MADT_DISPATCH(local_apic_address_override, madt_local_apic_address_override_t)
-                    madt_local_apic_address_override_t)
         default:
             break;
         }

kernel/include/init/multiboot2.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include "util/number.h"
-#include "util/function.h"
 #include "memory/pointer.h"
+#include "util/function.h"
+#include "util/number.h"
 
 namespace multiboot {
 
@@ -36,28 +36,50 @@ enum class tag_type : uint32_t {
 
 inline constexpr const char* get_tag_name(tag_type type) {
     switch (type) {
-        case tag_type::end:              return "end";
+    case tag_type::end:
-        case tag_type::cmdline:          return "cmdline";
+        return "end";
-        case tag_type::boot_loader_name: return "boot_loader_name";
+    case tag_type::cmdline:
-        case tag_type::module:           return "module";
+        return "cmdline";
-        case tag_type::basic_meminfo:    return "basic_meminfo";
+    case tag_type::boot_loader_name:
-        case tag_type::bootdev:          return "bootdev";
+        return "boot_loader_name";
-        case tag_type::mmap:             return "mmap";
+    case tag_type::module:
-        case tag_type::vbe:              return "vbe";
+        return "module";
-        case tag_type::framebuffer:      return "framebuffer";
+    case tag_type::basic_meminfo:
-        case tag_type::elf_sections:     return "elf_sections";
+        return "basic_meminfo";
-        case tag_type::apm:              return "apm";
+    case tag_type::bootdev:
-        case tag_type::efi32:            return "efi32";
+        return "bootdev";
-        case tag_type::efi64:            return "efi64";
+    case tag_type::mmap:
-        case tag_type::smbios:           return "smbios";
+        return "mmap";
-        case tag_type::acpi_old:         return "acpi_old";
+    case tag_type::vbe:
-        case tag_type::acpi_new:         return "acpi_new";
+        return "vbe";
-        case tag_type::network:          return "network";
+    case tag_type::framebuffer:
-        case tag_type::efi_mmap:         return "efi_mmap";
+        return "framebuffer";
-        case tag_type::efi_bs:           return "efi_bs";
+    case tag_type::elf_sections:
-        case tag_type::efi32_ih:         return "efi32_ih";
+        return "elf_sections";
-        case tag_type::efi64_ih:         return "efi64_ih";
+    case tag_type::apm:
-        case tag_type::load_base_addr:   return "load_base_addr";
+        return "apm";
+    case tag_type::efi32:
+        return "efi32";
+    case tag_type::efi64:
+        return "efi64";
+    case tag_type::smbios:
+        return "smbios";
+    case tag_type::acpi_old:
+        return "acpi_old";
+    case tag_type::acpi_new:
+        return "acpi_new";
+    case tag_type::network:
+        return "network";
+    case tag_type::efi_mmap:
+        return "efi_mmap";
+    case tag_type::efi_bs:
+        return "efi_bs";
+    case tag_type::efi32_ih:
+        return "efi32_ih";
+    case tag_type::efi64_ih:
+        return "efi64_ih";
+    case tag_type::load_base_addr:
+        return "load_base_addr";
     }
     return "";
 }
@@ -78,12 +100,18 @@ enum class mem_type : uint32_t {
 
 inline constexpr const char* get_mem_type_name(mem_type type) {
     switch (type) {
-        case mem_type::available:        return "available";
+    case mem_type::available:
-        case mem_type::reserved:         return "reserved";
+        return "available";
-        case mem_type::acpi_reclaimable: return "acpi_reclaimable";
+    case mem_type::reserved:
-        case mem_type::nvs:              return "nvs";
+        return "reserved";
-        case mem_type::badram:           return "badram";
+    case mem_type::acpi_reclaimable:
-        default:                         return "unknown";
+        return "acpi_reclaimable";
+    case mem_type::nvs:
+        return "nvs";
+    case mem_type::badram:
+        return "badram";
+    default:
+        return "unknown";
     }
 }
 
@@ -161,7 +189,6 @@ struct tag_vbe {
     vbe_mode_info_block vbe_mode_info;
 };
 
-
 struct tag_framebuffer {
     tag_type type;
     uint32_t size;
@@ -317,7 +344,8 @@ void visit(const tag* t, Fn&& fn) {
         MB_DISPATCH(efi32_ih, tag_efi32_ih)
         MB_DISPATCH(efi64_ih, tag_efi64_ih)
         MB_DISPATCH(load_base_addr, tag_load_base_addr)
-        default: break;
+    default:
+        break;
     }
 
 #undef MB_DISPATCH
@@ -329,7 +357,8 @@ void visit_all(const info* mb, Fn&& fn) {
     const auto end = reinterpret_cast<const uint8_t*>(mb) + mb->total_size;
     while (ptr < end) {
         auto t = reinterpret_cast<const tag*>(ptr);
-        if (t->type == tag_type::end) break;
+        if (t->type == tag_type::end)
+            break;
         visit(t, fn);
         ptr += (t->size + alignment - 1) & ~(alignment - 1);
     }

kernel/include/init/print.h

@@ -27,9 +27,7 @@ struct TextAttr {
     constexpr TextAttr(Color fg = Color::White, Color bg = Color::Black) : fg(fg), bg(bg) {}
 
     // Returns the attribute in the high byte, ready to OR with a character value.
-    constexpr uint16_t word() const {
+    constexpr uint16_t word() const { return (uint16_t)(((uint8_t)bg << 4) | (uint8_t)fg) << 8; }
-        return (uint16_t)(((uint8_t)bg << 4) | (uint8_t)fg) << 8;
-    }
 };
 
 void initFromLow();

kernel/include/memory/allocator.h

@@ -1,8 +1,8 @@
 #pragma once
 
+#include "init/multiboot2.h"
 #include "memory/pointer.h"
 #include "util/optional.h"
-#include "init/multiboot2.h"
 
 constexpr const size_t page_size = 4096;
 

kernel/include/memory/pointer.h

@@ -4,7 +4,12 @@
 
 constexpr uint64_t high_base = 0xFFFF800000000000;
 
-#define read_symbol(symbol) [](){uint64_t res; asm volatile("movabsq $" symbol ", %0": "=r"(res)); return res;}()
+#define read_symbol(symbol)                                                                                            \
+    []() {                                                                                                             \
+        uint64_t res;                                                                                                  \
+        asm volatile("movabsq $" symbol ", %0" : "=r"(res));                                                           \
+        return res;                                                                                                    \
+    }()
 
 struct paddr_t {
     uint64_t address;

kernel/include/memory/sections.h

@@ -21,8 +21,7 @@ void for_each_reserved_section(Fn&& fn) {
 inline bool is_in_reserved_section(paddr_t ptr, size_t size = 1) {
     bool res = false;
     for_each_reserved_section([&](const KernelSection& section) {
-        if (ptr.address < section.phys_end().address &&
+        if (ptr.address < section.phys_end().address && section.phys_start().address < ptr.address + size) {
-            section.phys_start().address < ptr.address + size) {
             res = true;
         }
     });

kernel/include/util/optional.h

@@ -26,12 +26,8 @@ public:
     using value_type = T;
 
     constexpr optional() : initialized(false) {}
-    optional(const T& value) : initialized(true) {
+    optional(const T& value) : initialized(true) { new (buffer) T(value); }
-        new (buffer) T(value);
+    optional(T&& value) : initialized(true) { new (buffer) T(move(value)); }
-    }
-    optional(T&& value) : initialized(true) {
-        new (buffer) T(move(value));
-    }
 
     optional(const optional& other) : initialized(other.initialized) {
         if (initialized) {
@@ -46,28 +42,19 @@ public:
         other.initialized = false;
     }
 
-    ~optional() {
+    ~optional() { destroy(); }
-        destroy();
-    }
 
-    T* operator->() {
+    T* operator->() { return (T*)buffer; }
-        return (T*) buffer;
-    }
 
-    T& operator*() {
+    T& operator*() { return *((T*)buffer); }
-        return *((T*) buffer);
-    }
 
-    const T* operator->() const {
+    const T* operator->() const { return (const T*)buffer; }
-        return (const T*) buffer;
-    }
 
-    const T& operator*() const {
+    const T& operator*() const { return *((const T*)buffer); }
-        return *((const T*) buffer);
-    }
 
     optional& operator=(const optional& other) {
-        if (this == &other) return *this;
+        if (this == &other)
+            return *this;
         destroy();
         if (other.initialized) {
             new (buffer) T(*other);
@@ -77,7 +64,8 @@ public:
     }
 
     optional& operator=(optional&& other) noexcept {
-        if (this == &other) return *this;
+        if (this == &other)
+            return *this;
         destroy();
         if (other.initialized) {
             new (buffer) T(move(*other));
@@ -87,17 +75,11 @@ public:
         return *this;
     }
 
-    [[nodiscard]] bool has_value() const {
+    [[nodiscard]] bool has_value() const { return initialized; }
-        return initialized;
-    }
 
-    T& value() {
+    T& value() { return *((T*)buffer); }
-        return *((T*) buffer);
-    }
 
-    const T& value() const {
+    const T& value() const { return *((const T*)buffer); }
-        return *((const T*) buffer);
-    }
 
     template<typename Func, typename... ArgT>
     T value_or_create(Func func, ArgT... args) {
@@ -125,13 +107,9 @@ public:
         }
     }
 
-    operator bool() const {
+    operator bool() const { return initialized; }
-        return initialized;
-    }
 
-    bool operator!() const {
+    bool operator!() const { return !initialized; }
-        return !initialized;
-    }
 
     template<typename R, typename Func, typename... ArgT>
     optional<R> map(Func func, ArgT... args) {

kernel/include/util/utility.h

@@ -3,11 +3,17 @@
 // Minimal freestanding replacements for <utility> (no stdlib available).
 
 template<typename T>
-struct remove_reference { using type = T; };
+struct remove_reference {
+    using type = T;
+};
 template<typename T>
-struct remove_reference<T&> { using type = T; };
+struct remove_reference<T&> {
+    using type = T;
+};
 template<typename T>
-struct remove_reference<T&&> { using type = T; };
+struct remove_reference<T&&> {
+    using type = T;
+};
 
 template<typename T>
 using remove_reference_t = typename remove_reference<T>::type;

kernel/src/init/cxxabi.cpp

@@ -6,5 +6,4 @@ void __cxa_pure_virtual() {
         __asm__ volatile("cli; hlt");
     }
 }
-
 }

kernel/src/init/init.cpp

@@ -1,14 +1,15 @@
-#include "memory/pointer.h"
-#include "memory/sections.h"
 #include "init/init.h"
-#include "init/multiboot2.h"
-#include "init/print.h"
 #include "init/acpi.h"
 #include "init/apic.h"
+#include "init/multiboot2.h"
+#include "init/print.h"
 #include "memory/allocator.h"
+#include "memory/pointer.h"
+#include "memory/sections.h"
 
 [[maybe_unused]] [[noreturn]] __attribute__((used)) static void halt() {
-    while (true) __asm__ volatile ("hlt");
+    while (true)
+        __asm__ volatile("hlt");
 }
 
 [[maybe_unused]] [[noreturn]] __attribute__((used)) static void panic(const char* msg) {
@@ -55,8 +56,7 @@ static bool is_in_boot_reserved_range(paddr_t ptr, size_t size) {
         if (length == 0) {
             return;
         }
-        if(ptr.address < start.address + length &&
+        if (ptr.address < start.address + length && start.address < ptr.address + size) {
-           start.address < ptr.address + size) {
             res = true;
         }
     });
@@ -145,12 +145,8 @@ void PhysicalAllocator::init(const multiboot::tag_mmap* multiboot_info) {
 }
 
 static void setupMemory() {
-    multiboot::visit_all(overloaded{
+    multiboot::visit_all(
-        [](const multiboot::tag_mmap* mem) {
+        overloaded{[](const multiboot::tag_mmap* mem) { PhysicalAllocator::init(mem); }, [](const auto* tag) {}});
-            PhysicalAllocator::init(mem);
-        },
-        [](const auto* tag) {}
-    });
 }
 
 static paddr_t rsdp_physical_of(const uint8_t* rsdp_payload) {
@@ -162,17 +158,13 @@ static paddr_t rsdp_physical_of(const uint8_t* rsdp_payload) {
 
 static acpi::Rsdp findRsdp() {
     optional<paddr_t> rsdp{};
-    multiboot::visit_all(overloaded{
+    multiboot::visit_all(overloaded{[&](const multiboot::tag_new_acpi* tag) { rsdp = rsdp_physical_of(tag->rsdp); },
-        [&](const multiboot::tag_new_acpi* tag) {
-            rsdp = rsdp_physical_of(tag->rsdp);
-        },
                                     [&](const multiboot::tag_old_acpi* tag) {
                                         if (!rsdp.has_value()) {
                                             rsdp = rsdp_physical_of(tag->rsdp);
                                         }
                                     },
-        [&](const auto* tag) {}
+                                    [&](const auto* tag) {}});
-    });
 
     if (!rsdp.has_value()) {
         panic("System could not find ACPI RSDP!");
@@ -187,12 +179,10 @@ struct AcpiDiscoveryResult {
 
 static void setupAcpi() {
     auto rsdp = findRsdp();
-    rsdp.for_each_table(overloaded{
+    rsdp.for_each_table(overloaded{[&](const acpi::sdt_header_t* header) {
-        [&](const acpi::sdt_header_t* header) {
         print(acpi::unfold_signature(header->signature).text);
         print("\n");
-        }
+    }});
-    });
 }
 
 [[maybe_unused]] [[noreturn]] __attribute__((used)) void init() {

kernel/src/init/sections.cpp

@@ -3,11 +3,7 @@
 #define RESERVE_SECTION(n)                                                                                             \
     extern char __##n##_start__[], __##n##_end__[];                                                                    \
     [[maybe_unused]] static const KernelSection _rsv_##n                                                               \
-    __attribute__((section(".reserved_ranges"), used)) = { \
+        __attribute__((section(".reserved_ranges"), used)) = {(uint64_t)__##n##_start__, (uint64_t)__##n##_end__, #n}
-        (uint64_t)__##n##_start__, \
-        (uint64_t)__##n##_end__, \
-        #n \
-    }
 
 RESERVE_SECTION(boot);
 RESERVE_SECTION(startup_text);

kernel/src/memory/allocator.cpp

@@ -56,9 +56,7 @@ struct PhysicalAllocatorImpl {
         return cursor;
     }
 
-    uint64_t& entry(size_t i) {
+    uint64_t& entry(size_t i) { return cursor_at(i).value(); }
-        return cursor_at(i).value();
-    }
 
     size_t node_count() {
         size_t nodes = 0;
@@ -68,9 +66,7 @@ struct PhysicalAllocatorImpl {
         return nodes;
     }
 
-    size_t capacity() {
+    size_t capacity() { return node_count() * entries_per_node; }
-        return node_count() * entries_per_node;
-    }
 
     size_t logical_length() {
         Cursor cursor = cursor_at(0);
@@ -87,9 +83,7 @@ struct PhysicalAllocatorImpl {
         }
     }
 
-    size_t free_slots() {
+    size_t free_slots() { return capacity() - (logical_length() + 2); }
-        return capacity() - (logical_length() + 2);
-    }
 
     optional<paddr_t> find_free_page() {
         Cursor cursor = cursor_at(0);
@@ -168,8 +162,8 @@ struct PhysicalAllocatorImpl {
         }
     }
 
-    run_list_t collect_runs(uint64_t start_page, uint64_t count, bool is_free,
+    run_list_t collect_runs(uint64_t start_page, uint64_t count, bool is_free, const run_location_t& start,
-                            const run_location_t& start, const run_location_t& end, size_t total_runs) {
+                            const run_location_t& end, size_t total_runs) {
         bool has_left_neighbor = start.index > 0;
         bool has_right_neighbor = end.index + 1 < total_runs;
         uint64_t left_remainder = start_page - start.address;

kernel/src/startup/entry.cpp

@@ -18,7 +18,8 @@ extern "C" [[maybe_unused]] [[noreturn]] __attribute__((used)) void __entry64()
         (*ctor)();
     }
     init();
-    while (true) __asm__ volatile ("hlt");
+    while (true)
+        __asm__ volatile("hlt");
 }
 
 asm(R"(