J'ai réfléchi un peu aux types entiers

diff --git a/kernel/src/elf64.cpp b/kernel/src/elf64.cpp
index 1b3f7c9d729b544954aaa848358aa7044c2be33f..239cb6bc1a15453705d1eed4c68a9e335266aa87 100644 (file)
--- a/kernel/src/elf64.cpp
+++ b/kernel/src/elf64.cpp
@@ -14,7 +14,7 @@
 #include "elf64.hpp"
 
 void os::elf::load_elf(os::process& result, amy::byte* start, amy::size length, const paging::PML4T& original_PML4T) {
-       os::assert(length >= 0 && (unsigned long long)(length) >= sizeof(os::elf::header), "Elf file isn't big enough to contain a header: there is an error.");
+       os::assert(length >= amy::byte_size<os::elf::header>(), "Elf file isn't big enough to contain a header: there is an error.");
        // TODO: Check that the elf file sections are all fully inside the file.
 
        // Load test-module elf file:
@@ -55,8 +55,8 @@ void os::elf::load_elf(os::process& result, amy::byte* start, amy::size length,
        result.r15 = 0;
 
        // Copy kernel mappings to the new virtual address space.
-       memset(result.PML4T->contents, 0, 256 * sizeof(os::paging::PML4E));
-       memcpy(result.PML4T->contents + 256, original_PML4T.contents + 256, 256 * sizeof(os::paging::PML4E));
+       memset(result.PML4T->contents, 0, 256 * amy::byte_size<os::paging::PML4E>());
+       memcpy(result.PML4T->contents + 256, original_PML4T.contents + 256, 256 * amy::byte_size<os::paging::PML4E>());
 
        for (amy::size i = 0; i < elf_header.entry_count_program_header_table; i++) {
                const os::elf::program_header program_header = *(os::elf::program_header*)(

diff --git a/kernel/src/elf64.hpp b/kernel/src/elf64.hpp
index 8ae4df3b580c5ffc34271ed19026f163fc9bf9a3..9347353f0aa868ad92f0e4dca70d53960944683c 100644 (file)
--- a/kernel/src/elf64.hpp
+++ b/kernel/src/elf64.hpp
@@ -42,7 +42,7 @@ namespace os { namespace elf {
                amy::u16 entry_count_section_header_table;
                amy::u16 index_section_names_section_header_table;
        };
-       static_assert(sizeof(header) == 64);
+       static_assert(amy::byte_size<header>() == 64);
 
        struct program_header {
                amy::u32 type;
@@ -54,7 +54,7 @@ namespace os { namespace elf {
                amy::u64 p_memsz;
                amy::u64 align;
        };
-       static_assert(sizeof(program_header) == 56);
+       static_assert(amy::byte_size<program_header>() == 56);
 
        void load_elf(os::process& result, amy::byte* start, amy::size length, const paging::PML4T& original_PML4T);
 } } // namespace os::elf

diff --git a/kernel/src/interrupts.cpp b/kernel/src/interrupts.cpp
index 11ca4d7df043bfad823ce5aac503969f4ffacdf5..228803966136127ced4635e61a8c07f86aa65d97 100644 (file)
--- a/kernel/src/interrupts.cpp
+++ b/kernel/src/interrupts.cpp
@@ -29,18 +29,18 @@ void os::disable_PIC() {
        outb(0x21, 0xFF);
 }
 void os::set_APIC_base(os::phys_ptr<volatile amy::u32> ptr) {
-       os::set_msr(0x1B, (ptr.get_phys_addr() & 0xFFFFFFFFFFFFF000) | 0x800);
+       os::set_msr(0x1B, (ptr.get_phys_addr() & 0xFFFF'FFFF'FFFF'F000) | 0x800);
 }
 os::phys_ptr<volatile amy::u32> os::get_APIC_base() {
-       return os::phys_ptr<volatile amy::u32>{os::get_msr(0x1B) & 0xFFFFFFFFFFFFF000};
+       return os::phys_ptr<volatile amy::u32>{amy::ptr(os::get_msr(0x1B)) & amy::ptr(0xFFFF'FFFF'FFFF'F000)};
 }
-amy::u32 os::get_APIC_reg(amy::dptr offset) {
+amy::u32 os::get_APIC_reg(amy::diff offset) {
        return get_APIC_base()[offset / 4];
 }
-void os::set_APIC_reg(amy::dptr offset, amy::u32 v) {
+void os::set_APIC_reg(amy::diff offset, amy::u32 v) {
        get_APIC_base()[offset / 4] = v;
 }
-extern "C" void set_APIC_reg_asm(amy::dptr offset, amy::u32 v) {
+extern "C" void set_APIC_reg_asm(amy::diff offset, amy::u32 v) {
        os::set_APIC_reg(offset, v);
 }
 

diff --git a/kernel/src/interrupts.hpp b/kernel/src/interrupts.hpp
index 2d9aa472db2d249143caec79be4136d21d62f829..564a4b66b4bcab1513d7fffdcdb0676633e983d4 100644 (file)
--- a/kernel/src/interrupts.hpp
+++ b/kernel/src/interrupts.hpp
@@ -33,13 +33,13 @@ struct ide {
        amy::u32 offset_high;
        amy::u32 reserved_2 = 0;
 };
-static_assert(sizeof(ide) == 16);
+static_assert(amy::byte_size<ide>() == 16);
 template <amy::size interrupt_nb>
 using idt __attribute__((aligned(0x1000))) = ide[interrupt_nb];
 
 struct __attribute__((packed)) idtr {
        amy::u16 size;
-       amy::u64 offset;
+       amy::ptr offset;
 };
 
 void lidt(idtr idtr);
@@ -47,11 +47,11 @@ bool is_APIC_builtin();
 void disable_PIC();
 void set_APIC_base(phys_ptr<volatile amy::u32> ptr);
 phys_ptr<volatile amy::u32> get_APIC_base();
-amy::u32 get_APIC_reg(amy::dptr offset);
-void set_APIC_reg(amy::dptr offset, amy::u32 v);
+amy::u32 get_APIC_reg(amy::diff offset);
+void set_APIC_reg(amy::diff offset, amy::u32 v);
 
 struct isr_info {
-       amy::uptr addr;
+       amy::ptr addr;
        enum class type_t { trap_gate = 0xF, interrupt_gate = 0xE };
        type_t type : 4;
        amy::u8 dpl: 2 = 0b00;
@@ -82,8 +82,8 @@ void enable_interrupts(const isr_info (&ISRs)[interrupt_nb], os::idt<interrupt_n
        }
 
        os::idtr idtr {
-               .size = sizeof(idt) - 1,
-               .offset = reinterpret_cast<amy::uptr>(&idt[0]),
+               .size = amy::byte_size<decltype(idt)>() - 1,
+               .offset = reinterpret_cast<amy::ptr>(&idt[0]),
        };
        lidt(idtr);
        sti();

diff --git a/kernel/src/kernel.cpp b/kernel/src/kernel.cpp
index bffc658e289386c164d846b75d988e6a971e5b50..cc709beb53d1785e2664a1a9718ab1be2ced137b 100644 (file)
--- a/kernel/src/kernel.cpp
+++ b/kernel/src/kernel.cpp
@@ -38,21 +38,21 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
        os::assert(magic == 0x36D76289, "Incorrect magic number: wasn't booted with multiboot2.");
 
        os::paging::page_allocator.deallocate({
-               .ptr = os::phys_ptr<os::paging::page<0>>(reinterpret_cast<uintptr_t>(bootstrap_pages_for_memory) - 0xFFFF'FFFF'8000'0000),
-               .size = sizeof(bootstrap_pages_for_memory) / sizeof(bootstrap_pages_for_memory[0])
+               .ptr = os::phys_ptr<os::paging::page<0>>(amy::ptr(&bootstrap_pages_for_memory) & amy::ptr(~0xFFFF'FFFF'8000'0000)),
+               .size = amy::byte_size<decltype(bootstrap_pages_for_memory)>() / amy::byte_size<decltype(bootstrap_pages_for_memory[0])>()
        });
 
        os::assert(os::cpu_has_msr(), "MSRs aren't supported.");
        // Initialise kernel map.
-       os::assert(amy::iptr(&_kernel_phys_start) % 4096 == 0, "Kernel isn't page aligned !");
-       os::assert(amy::iptr(&_kernel_phys_rw_start) % 4096 == 0, "Kernel isn't page aligned !");
-       os::assert(amy::iptr(&_kernel_phys_end) % 4096 == 0, "Kernel isn't page aligned !");
-       for (amy::size i = amy::iptr(&_kernel_phys_start); i < amy::iptr(&_kernel_phys_rw_start); ) {
-               if (i % (1024 * 1024 * 1024) == 0 && i + 1024 * 1024 * 1024 < amy::iptr(&_kernel_phys_rw_start)) {
+       os::assert(amy::ptr(&_kernel_phys_start) % 4096 == 0, "Kernel isn't page aligned !");
+       os::assert(amy::ptr(&_kernel_phys_rw_start) % 4096 == 0, "Kernel isn't page aligned !");
+       os::assert(amy::ptr(&_kernel_phys_end) % 4096 == 0, "Kernel isn't page aligned !");
+       for (amy::size i = amy::ptr(&_kernel_phys_start); i < amy::ptr(&_kernel_phys_rw_start); ) {
+               if (i % (1024 * 1024 * 1024) == 0 && i + 1024 * 1024 * 1024 < amy::ptr(&_kernel_phys_rw_start)) {
                        os::paging::map_page<2, 3>(os::paging::global_PML4T, (os::paging::page<2>*)(0xFFFF'FFFF'8000'0000 + i), os::phys_ptr<os::paging::page<2>>(i),
                                { .RW = false, .US = false, .PWT = false, .PCD = false, .A = false, .D = false, .PAT = false, .G = true, .AVL = 0, .NX = false });
                        i += 1024 * 1024 * 1024;
-               } else if (i % (1024 * 1024 * 2) == 0 && i + 1024 * 1024 * 2 < amy::iptr(&_kernel_phys_rw_start)) {
+               } else if (i % (1024 * 1024 * 2) == 0 && i + 1024 * 1024 * 2 < amy::ptr(&_kernel_phys_rw_start)) {
                        os::paging::map_page<1, 3>(os::paging::global_PML4T, (os::paging::page<1>*)(0xFFFF'FFFF'8000'0000 + i), os::phys_ptr<os::paging::page<1>>(i),
                                { .RW = false, .US = false, .PWT = false, .PCD = false, .A = false, .D = false, .PAT = false, .G = true, .AVL = 0, .NX = false });
                        i += 1024 * 1024 * 2;
@@ -62,12 +62,12 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                        i += 1024 * 4;
                }
        }
-       for (amy::size i = amy::iptr(&_kernel_phys_rw_start); i < amy::iptr(&_kernel_phys_end); ) {
-               if (i % (1024 * 1024 * 1024) == 0 && i + 1024 * 1024 * 1024 < amy::iptr(&_kernel_phys_rw_start)) {
+       for (amy::size i = amy::ptr(&_kernel_phys_rw_start); i < amy::ptr(&_kernel_phys_end); ) {
+               if (i % (1024 * 1024 * 1024) == 0 && i + 1024 * 1024 * 1024 < amy::ptr(&_kernel_phys_rw_start)) {
                        os::paging::map_page<2, 3>(os::paging::global_PML4T, (os::paging::page<2>*)(0xFFFF'FFFF'8000'0000 + i), os::phys_ptr<os::paging::page<2>>(i),
                                { .RW = true, .US = false, .PWT = false, .PCD = false, .A = false, .D = false, .PAT = false, .G = true, .AVL = 0, .NX = true });
                        i += 1024 * 1024 * 1024;
-               } else if (i % (1024 * 1024 * 2) == 0 && i + 1024 * 1024 * 2 < amy::iptr(&_kernel_phys_rw_start)) {
+               } else if (i % (1024 * 1024 * 2) == 0 && i + 1024 * 1024 * 2 < amy::ptr(&_kernel_phys_rw_start)) {
                        os::paging::map_page<1, 3>(os::paging::global_PML4T, (os::paging::page<1>*)(0xFFFF'FFFF'8000'0000 + i), os::phys_ptr<os::paging::page<1>>(i),
                                { .RW = true, .US = false, .PWT = false, .PCD = false, .A = false, .D = false, .PAT = false, .G = true, .AVL = 0, .NX = true });
                        i += 1024 * 1024 * 2;
@@ -83,8 +83,8 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                case multiboot2::info::type_t::memory_map:
                        os::print("RAM:\n");
                        for (amy::size i = 0; i < multiboot2::memory_map_number_of_entries(it); i++) {
-                               amy::iptr const s = multiboot2::memory_map_base_addr(it, i);
-                               amy::iptr const e = s + multiboot2::memory_map_length(it, i);
+                               amy::ptr const s = multiboot2::memory_map_base_addr(it, i);
+                               amy::ptr const e = s + multiboot2::memory_map_length(it, i);
                                os::print("{} -> {} : {}\n", (void*)s, (void*)e, multiboot2::memory_map_type(it, i));
                                if (multiboot2::memory_map_type(it, i) != 1) {
                                        continue;
@@ -94,7 +94,7 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                                }
                                os::assert(s % 0x1000 == 0, "Memory map unaligned on page boundaries.");
                                os::assert(e % 0x1000 == 0, "Memory map unaligned on page boundaries.");
-                               for (amy::iptr j = s; j < e; ) {
+                               for (amy::ptr j = s; j < e; ) {
                                        if (j % (1024 * 1024 * 1024) == 0 && j + 1024 * 1024 * 1024 < e) {
                                                os::paging::map_page<2, 3>(
                                                        os::paging::global_PML4T,
@@ -126,11 +126,11 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                }
        }
        // /TODO
-       os::paging::load_pml4t(os::phys_ptr<os::paging::PML4T>{amy::uptr(&os::paging::global_PML4T) - 0xFFFF'FFFF'8000'0000});
+       os::paging::load_pml4t(os::phys_ptr<os::paging::PML4T>{amy::ptr(&os::paging::global_PML4T) & amy::ptr(~0xFFFF'FFFF'8000'0000)});
 
        { // Enable interrupts really early so I don't have to manually manage memory... Will make better later, when I make utils.hpp/incrementing_int64_map better.
                os::isr_info isr_info[32];
-               for (amy::size i = 0; (unsigned long long)(i) < sizeof(isr_info) / sizeof(isr_info[0]); i++) {
+               for (amy::size i = 0; i < amy::byte_size<decltype(isr_info)>() / amy::byte_size<decltype(isr_info[0])>(); i++) {
                        isr_info[i].type = os::isr_info::type_t::trap_gate;
                }
                asm ("movq $handler_0x00,%0" : "=ri"(isr_info[0x00].addr) : );
@@ -175,7 +175,7 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
 
        // Allocate those pages so that I only ever need to update the mapping once when I create a new process or port.
        // TODO: Not an emergency, but adapt in case we need multiple PML4Es. (*NOT* the case right now.)
-       static_assert(sizeof(os::processes) <= 1024 * 1024 * 1024, "Error: processes array too big.");
+       static_assert(amy::byte_size<decltype(os::processes)>() <= 1024 * 1024 * 1024, "Error: processes array too big.");
        {
                amy::size const index = (amy::size(&os::processes) >> (12 + 9 * 3)) & 0x1FF;
                os::paging::global_PML4T.contents[index].paging_table_info({.RW = true, .US = false, .PWT = false, .PCD = false, .A = false, .AVL = 0, .NX = false});
@@ -217,7 +217,7 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                        case multiboot2::info::type_t::modules:
                                os::print("{}->{}: {}\n", multiboot2::modules_mod_start(it), multiboot2::modules_mod_end(it), multiboot2::modules_string(it));
                                module_specified = true;
-                               os::elf::load_elf(os::get_process(os::processes.create()),
+                               os::elf::load_elf(os::get_process(amy::pid(os::processes.create())),
                                                  (amy::byte*)multiboot2::modules_mod_start(it),
                                                  multiboot2::modules_mod_end(it) - multiboot2::modules_mod_start(it),
                                                  os::paging::global_PML4T);
@@ -229,11 +229,11 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                os::assert(module_specified, "No modules specified in the multiboot. This is unsupported.");
 
                // kernel_start and kernel_end are aligned to 4K by the linker script.
-               const os::phys_ptr<os::paging::page<0>> kernel_s{amy::uptr(&_kernel_phys_start)};
-               const os::phys_ptr<os::paging::page<0>> kernel_e{amy::uptr(&_kernel_phys_end)};
+               const os::phys_ptr<os::paging::page<0>> kernel_s{amy::ptr(&_kernel_phys_start)};
+               const os::phys_ptr<os::paging::page<0>> kernel_e{amy::ptr(&_kernel_phys_end)};
 
                // Remove kernel from available RAM:
-               for (amy::iptr i = 0; i < available_ram_length; i++) {
+               for (amy::ptr i = 0; i < available_ram_length; i++) {
                        if (kernel_e < available_ram[i].start_address || available_ram[i].end_address < kernel_s) {
                                continue;
                        }
@@ -254,7 +254,7 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
                }
 
                // Add available RAM to the page allocator (warning: overrides the multiboot info structure and the multiboot modules):
-               for (amy::iptr i = 0; i < available_ram_length; i++) {
+               for (amy::ptr i = 0; i < available_ram_length; i++) {
                        os::paging::page_allocator.deallocate({
                                .ptr = available_ram[i].start_address,
                                .size = amy::size(available_ram[i].end_address - available_ram[i].start_address + 1)
@@ -274,5 +274,5 @@ extern "C" void kmain(unsigned long magic, os::phys_ptr<const multiboot2::info_s
        os::enable_syscalls();
 
        os::print("Moving to ring 3.\n");
-       os::run_first_process(0);
+       os::run_first_process(amy::pid(0));
 }

diff --git a/kernel/src/lib/multiboot2.hpp b/kernel/src/lib/multiboot2.hpp
index 61b6df98b6de64f1d6b4a5c7ebb830d44820c507..719edd891052d78cf9aa98daa9d8a4c51c72c63e 100644 (file)
--- a/kernel/src/lib/multiboot2.hpp
+++ b/kernel/src/lib/multiboot2.hpp
@@ -104,8 +104,8 @@
        inline amy::size memory_map_number_of_entries(os::phys_ptr<const info> ptr) {
                return (ptr->size - 16) / memory_map_entry_size(ptr);
        }
-       inline amy::u64 memory_map_base_addr(os::phys_ptr<const info> ptr, amy::size index) {
-               return *reinterpret_cast<const amy::u64*>(&ptr->rest[8 + memory_map_entry_size(ptr) * index +  0]);
+       inline amy::ptr memory_map_base_addr(os::phys_ptr<const info> ptr, amy::size index) {
+               return *reinterpret_cast<const amy::ptr*>(&ptr->rest[8 + memory_map_entry_size(ptr) * index +  0]);
        }
        inline amy::u64 memory_map_length(os::phys_ptr<const info> ptr, amy::size index) {
                return *reinterpret_cast<const amy::u64*>(&ptr->rest[8 + memory_map_entry_size(ptr) * index +  8]);

diff --git a/kernel/src/lib/phys_ptr.hpp b/kernel/src/lib/phys_ptr.hpp
index 400f5e90800e9c7e6dfc7e2de5001760c7028471..4fb474ac1b3f5023962891d07c73bf41413338cd 100644 (file)
--- a/kernel/src/lib/phys_ptr.hpp
+++ b/kernel/src/lib/phys_ptr.hpp
@@ -14,6 +14,7 @@
 #pragma once
 
 #include <types.hpp>
+#include <memory.hpp>
 
 namespace os {
 
@@ -23,8 +24,8 @@ class phys_ptr;
 template <>
 class phys_ptr<void> {
 public:
-       constexpr explicit phys_ptr(amy::uptr phys_addr): phys_addr(phys_addr) {}
-       constexpr phys_ptr(amy::nptr): phys_addr(~0ull) {}
+       constexpr explicit phys_ptr(amy::ptr phys_addr): phys_addr(phys_addr) {}
+       constexpr phys_ptr(amy::nil_t): phys_addr(0xF000'0000'0000'0000) {}
 
        inline void* operator->() const {
                return get_virt_addr();
@@ -33,7 +34,7 @@ public:
                return get_virt_addr();
        }
 
-       constexpr amy::uptr get_phys_addr() const {
+       constexpr amy::ptr get_phys_addr() const {
                return phys_addr;
        }
 
@@ -49,16 +50,16 @@ private:
                return reinterpret_cast<void*>(phys_addr + 0xFFFF800000000000);
        }
 
-       amy::uptr phys_addr;
+       amy::ptr phys_addr;
 };
 
 template <typename T>
 class phys_ptr {
 public:
-       constexpr explicit phys_ptr(amy::uptr phys_addr): phys_addr(phys_addr) {}
-       constexpr phys_ptr(amy::nptr): phys_addr(~0ull) {}
+       constexpr explicit phys_ptr(amy::ptr phys_addr): phys_addr(phys_addr) {}
+       constexpr phys_ptr(amy::nil_t): phys_addr(0xF000'0000'0000'0000) {}
 
-       T& operator[](amy::size i) const {
+       T& operator[](amy::diff i) const {
                return get_virt_addr()[i];
        }
        T& operator*() const {
@@ -93,27 +94,27 @@ public:
                operator--();
                return old;
        }
-       constexpr phys_ptr<T>& operator+=(amy::dptr offset) {
+       constexpr phys_ptr<T>& operator+=(amy::diff offset) {
                return *this = *this + offset;
        }
-       constexpr phys_ptr<T>& operator-=(amy::dptr offset) {
+       constexpr phys_ptr<T>& operator-=(amy::diff offset) {
                return *this = *this - offset;
        }
 
-       friend constexpr phys_ptr<T> operator+(phys_ptr<T> ptr, amy::dptr offset) {
-               return phys_ptr<T>{ptr.phys_addr + offset * sizeof(T)};
+       friend constexpr phys_ptr<T> operator+(phys_ptr<T> ptr, amy::diff offset) {
+               return phys_ptr<T>{ptr.phys_addr + offset * amy::byte_size<T>()};
        }
-       friend constexpr phys_ptr<T> operator+(amy::dptr offset, phys_ptr<T> ptr) {
+       friend constexpr phys_ptr<T> operator+(amy::diff offset, phys_ptr<T> ptr) {
                return ptr + offset;
        }
-       friend constexpr phys_ptr<T> operator-(phys_ptr<T> ptr, amy::dptr offset) {
-               return phys_ptr<T>{ptr.phys_addr - offset * sizeof(T)};
+       friend constexpr phys_ptr<T> operator-(phys_ptr<T> ptr, amy::diff offset) {
+               return phys_ptr<T>{ptr.phys_addr - offset * amy::byte_size<T>()};
        }
-       friend constexpr amy::dptr operator-(phys_ptr<T> a, phys_ptr<T> b) {
-               return (a.phys_addr - b.phys_addr) / sizeof(T);
+       friend constexpr amy::diff operator-(phys_ptr<T> a, phys_ptr<T> b) {
+               return (a.phys_addr - b.phys_addr) / amy::byte_size<T>();
        }
 
-       constexpr amy::uptr get_phys_addr() const {
+       constexpr amy::ptr get_phys_addr() const {
                return phys_addr;
        }
 
@@ -141,7 +142,7 @@ private:
                return reinterpret_cast<T*>(phys_addr + 0xFFFF800000000000);
        }
 
-       amy::uptr phys_addr;
+       amy::ptr phys_addr;
 };
 
 } // namespace os

diff --git a/kernel/src/paging.hpp b/kernel/src/paging.hpp
index bae565700fa77a946805ba299345597fbee8737c..7b8087d6bf5e45abd0cc2f5f9c2c5f620903d8ab 100644 (file)
--- a/kernel/src/paging.hpp
+++ b/kernel/src/paging.hpp
@@ -77,7 +77,7 @@ template <amy::size depth> struct paging_entry {
        }
        os::phys_ptr<os::paging::page<depth>> page_ptr() {
                os::assert(is_page(), "Cannot access page physical pointer for a non-page.");
-               amy::uptr addr = data & (depth == 0 ? 0x0000'FFFF'FFFF'F000 : 0x0000'FFFF'FFFF'E000);
+               amy::ptr addr = data & (depth == 0 ? 0x0000'FFFF'FFFF'F000 : 0x0000'FFFF'FFFF'E000);
                return os::phys_ptr<os::paging::page<depth>>(addr | ((addr & 0x0000'8000'0000'0000) != 0 ? 0xFFFF'8000'0000'0000 : 0));
        }
        void page_ptr(os::phys_ptr<os::paging::page<depth>> page) {
@@ -104,7 +104,7 @@ template <amy::size depth> struct paging_entry {
        }
        os::phys_ptr<os::paging::paging_table<depth - 1>> paging_table_ptr() {
                os::assert(!is_page(), "Cannot access paging table physical pointer for a page.");
-               amy::uptr addr = data & 0x0000'FFFF'FFFF'F000;
+               amy::ptr addr = data & 0x0000'FFFF'FFFF'F000;
                return os::phys_ptr<os::paging::paging_table<depth - 1>>(addr | ((addr & 0x0000'8000'0000'0000) != 0 ? 0xFFFF'8000'0000'0000 : 0));
        }
        void paging_table_ptr(os::phys_ptr<os::paging::paging_table<depth - 1>> table) {
@@ -150,25 +150,25 @@ template <amy::size depth> struct __attribute__((aligned(0x1000))) page {
        amy::byte contents[0x1000ull << (9 * depth)];
 };
 
-static_assert(sizeof(page<0>) == 0x1000);
-static_assert(sizeof(page<1>) == 0x1000 * 512);
-static_assert(sizeof(page<2>) == 0x1000ull * 512 * 512);
-static_assert(sizeof(paging_table<3>) == 0x1000);
+static_assert(amy::byte_size<page<0>>() == 0x1000);
+static_assert(amy::byte_size<page<1>>() == 0x1000 * 512);
+static_assert(amy::byte_size<page<2>>() == 0x1000ull * 512 * 512);
+static_assert(amy::byte_size<paging_table<3>>() == 0x1000);
 static_assert(alignof(paging_table<3>) == 0x1000);
 static_assert(alignof(paging_entry<3>) == 8);
-static_assert(sizeof(paging_entry<3>) == 8);
-static_assert(sizeof(paging_table<2>) == 0x1000);
+static_assert(amy::byte_size<paging_entry<3>>() == 8);
+static_assert(amy::byte_size<paging_table<2>>() == 0x1000);
 static_assert(alignof(paging_table<2>) == 0x1000);
 static_assert(alignof(paging_entry<2>) == 8);
-static_assert(sizeof(paging_entry<2>) == 8);
-static_assert(sizeof(paging_table<1>) == 0x1000);
+static_assert(amy::byte_size<paging_entry<2>>() == 8);
+static_assert(amy::byte_size<paging_table<1>>() == 0x1000);
 static_assert(alignof(paging_table<1>) == 0x1000);
 static_assert(alignof(paging_entry<1>) == 8);
-static_assert(sizeof(paging_entry<1>) == 8);
-static_assert(sizeof(paging_table<0>) == 0x1000);
+static_assert(amy::byte_size<paging_entry<1>>() == 8);
+static_assert(amy::byte_size<paging_table<0>>() == 0x1000);
 static_assert(alignof(paging_table<0>) == 0x1000);
 static_assert(alignof(paging_entry<0>) == 8);
-static_assert(sizeof(paging_entry<0>) == 8);
+static_assert(amy::byte_size<paging_entry<0>>() == 8);
 
 using PML4T = paging_table<3>;
 using PML4E = paging_entry<3>;
@@ -184,7 +184,7 @@ extern PML4T global_PML4T;
 template <amy::size depth, amy::size paging_depth = 3>
 void map_page(paging_table<paging_depth>& paging_table, page<depth> const* vaddr, phys_ptr<page<depth>> paddr, os::paging::page_info page_info);
 template <amy::size depth>
-void on_all_pages(const paging_table<depth>& paging_table, auto f, amy::uptr vaddr_offset = 0);
+void on_all_pages(const paging_table<depth>& paging_table, auto f, amy::diff vaddr_offset = 0);
 
 void load_pml4t(phys_ptr<PML4T> PML4T);
 
@@ -209,7 +209,7 @@ private:
                phys_ptr<page> next;
                amy::size size;
        };
-       static_assert(sizeof(page) == 0x1000);
+       static_assert(amy::byte_size<page>() == 0x1000);
        static_assert(alignof(page) == 0x1000);
        phys_ptr<page> begin;
 
@@ -218,7 +218,7 @@ private:
 
 template <amy::size depth, amy::size paging_depth>
 void map_page(paging_table<paging_depth>& paging_table, page<depth> const* vaddr, phys_ptr<page<depth>> paddr, os::paging::page_info page_info) {
-       amy::size const index = (amy::uptr(vaddr) >> (12 + 9 * paging_depth)) & 0x1FF;
+       amy::size const index = (amy::ptr(vaddr) >> (12 + 9 * paging_depth)) & 0x1FF;
        if constexpr (depth == paging_depth) {
                os::assert(!paging_table.contents[index].is_present(), "Virtual address 0x{} is already mapped.", vaddr);
                paging_table.contents[index].page_info(page_info);
@@ -240,13 +240,13 @@ void map_page(paging_table<paging_depth>& paging_table, page<depth> const* vaddr
 }
 
 template <amy::size depth>
-void on_all_pages(const paging_table<depth>& paging_table, auto f, amy::uptr vaddr_offset) {
+void on_all_pages(const paging_table<depth>& paging_table, auto f, amy::diff vaddr_offset) {
        for (amy::size i = 0; i < 512; i++) {
                if (!is_present(paging_table.contents[i])) {
                        continue;
                }
-               amy::uptr const new_offset = ([&]() {
-                       amy::uptr const new_offset = vaddr_offset + (i << (12 + 9 * depth));
+               amy::diff const new_offset = ([&]() {
+                       amy::diff const new_offset = vaddr_offset + (i << (12 + 9 * depth));
                        return new_offset | (new_offset >> 47 ? 0xFFFF'8000'0000'0000 : 0);
                })();
                if constexpr (depth == 3) {

diff --git a/kernel/src/ring3.cpp b/kernel/src/ring3.cpp
index 4625e1e57bfc4a73ec627580602b1a3e0a015d01..5df22c534f0110316c6f3690f507ce628b37ac64 100644 (file)
--- a/kernel/src/ring3.cpp
+++ b/kernel/src/ring3.cpp
@@ -16,7 +16,7 @@
 #include "serial.hpp"
 #include "paging.hpp"
 
-void os::run_first_process(amy::i64 pid) {
+void os::run_first_process(amy::pid pid) {
        current_pid = pid;
        os::paging::load_pml4t(os::get_process(current_pid).PML4T);
        os::ftl_to_userspace((void*)os::get_process(current_pid).rip, (amy::byte*)os::get_process(current_pid).rsp);
@@ -41,12 +41,12 @@ void os::enable_syscalls() {
 }
 
 void schedule_next_process() {
-       if (os::processes.present(os::current_pid + 1)) {
-               os::current_pid += 1;
+       if (os::processes.present(amy::i64(os::current_pid) + 1)) {
+               os::current_pid = amy::pid(amy::i64(os::current_pid) + 1);
        } else {
-               os::current_pid = 0;
+               os::current_pid = amy::pid(0);
        }
-       os::paging::load_pml4t(os::processes.get(os::current_pid).PML4T);
+       os::paging::load_pml4t(os::processes.get(amy::i64(os::current_pid)).PML4T);
 }
 
 // extern "C" int os::syscall_mount_kernel_device(amy::fd wd, char device, char const* path, amy::size path_len, int mount_type);
@@ -62,7 +62,7 @@ extern "C" amy::fd os::syscall_open(amy::fd, char const*, amy::size, int) {
 }
 
 extern "C" amy::size os::syscall_read(amy::fd file, char* data, amy::size len) {
-       os::assert(file == 0, "Read isn't really implemented for now.");
+       os::assert(file == amy::fd(0), "Read isn't really implemented for now.");
        os::assert(len >= 0, "Read expects a positive size.");
        if (len == 0) {
                return 0;
@@ -82,7 +82,7 @@ extern "C" amy::size os::syscall_read(amy::fd file, char* data, amy::size len) {
 }
 
 extern "C" amy::size os::syscall_write(amy::fd file, char const* data, amy::size len) {
-       os::assert(file == 0, "Write isn't really implemented for now.");
+       os::assert(file == amy::fd(0), "Write isn't really implemented for now.");
        os::assert(len >= 0, "Write expects a positive size.");
        if (len == 0) {
                return 0;
@@ -111,5 +111,5 @@ extern "C" void os::syscall_rax_error_handler() {
 os::incrementing_int64_map<os::process>& os::processes = *reinterpret_cast<os::incrementing_int64_map<os::process>*>(0xFFFF'C000'0000'0000);
 amy::pid os::current_pid;
 os::process& os::get_process(amy::pid pid) {
-       return processes.get(pid);
+       return processes.get(amy::i64(pid));
 }

diff --git a/kernel/src/ring3.hpp b/kernel/src/ring3.hpp
index b79b7a59ee588f796816ab8f1c152582b19cc689..68595265bfa5a5ba4e04c99c9e3b124fee11a045 100644 (file)
--- a/kernel/src/ring3.hpp
+++ b/kernel/src/ring3.hpp
@@ -39,7 +39,7 @@ struct __attribute__((packed)) tss {
 struct process;
 
 extern "C" void ftl_to_userspace(void* program, amy::byte* stack);
-void run_first_process(amy::i64 pid);
+void run_first_process(amy::pid pid);
 extern "C" void load_tss();
 extern "C" void syscall_64bit_handler();
 
@@ -82,10 +82,10 @@ struct process {
        incrementing_int64_map<port> ports;
 };
 
-static_assert(0xFFFF'C000'0000'0000 + sizeof(incrementing_int64_map<process>) < 0xFFFF'FFFF'8000'0000);
+static_assert(0xFFFF'C000'0000'0000 + amy::byte_size<incrementing_int64_map<process>>() < 0xFFFF'FFFF'8000'0000);
 
 extern incrementing_int64_map<process>& processes;
 extern "C" amy::pid current_pid;
-extern "C" process& get_process(amy::i64 pid);
+extern "C" process& get_process(amy::pid pid);
 
 } // namespace os

diff --git a/kernel/src/serial.cpp b/kernel/src/serial.cpp
index a686584b9d824e03a3f527ced9b2e58f117ccda1..5f2f58a179c8b313caea791e2dcd7287bd72050c 100644 (file)
--- a/kernel/src/serial.cpp
+++ b/kernel/src/serial.cpp
@@ -95,7 +95,7 @@ void os::print_formatted(const char* format, const void* val) {
        os::assert(format[0] == '}', "Format string unsupported. TODO.");
        os::print("0x");
        for (int i = 60; i >= 0; i -= 4) {
-               const int v = (reinterpret_cast<amy::uptr>(val) >> i) & 0xF;
+               const int v = (reinterpret_cast<amy::ptr>(val) >> i) & 0xF;
                os::printc(v < 10 ? v + '0' : v - 10 + 'a');
        }
 }

diff --git a/kernel/src/utils.hpp b/kernel/src/utils.hpp
index 035760e7495ab923197adee1924472d8afb937a1..b3a8edbaa4a1e67d34c99b1e69025fba0054a309 100644 (file)
--- a/kernel/src/utils.hpp
+++ b/kernel/src/utils.hpp
@@ -75,7 +75,7 @@ public:
 private:
        struct elem_t {
                bool present;
-               alignas(T) amy::byte buffer[sizeof(T)];
+               alignas(T) amy::byte buffer[amy::byte_size<T>()];
        };
        amy::i64 n = 0;
        static constexpr amy::i64 max_n = 4096;

diff --git a/libcpp/memory.hpp b/libcpp/memory.hpp
index 81ae2a62ff35873eabc60cb62dbf9813cdb89d7f..40c38d5853c3e696f07800448f9b5778de92068e 100644 (file)
--- a/libcpp/memory.hpp
+++ b/libcpp/memory.hpp
@@ -29,9 +29,18 @@ inline void operator delete[](void*, void*) noexcept {}
 
 namespace amy {
 
-// Taken from glibcxx, should be fine copyright-wise:
+// "Launder" taken from glibcxx, should be fine copyright-wise:
 template <typename T>
 [[nodiscard]] constexpr T* launder(T* p) noexcept {
        return __builtin_launder(p);
 }
+
+
+template <typename T> constexpr size byte_size() {
+       return sizeof(T);
+}
+template <typename T> constexpr size byte_align() {
+       return alignof(T);
+}
+
 } // namespace amy

diff --git a/libcpp/types.hpp b/libcpp/types.hpp
index 2e7f2d63c8509dab5f0ca96dbe0dcbdc9d3e2234..94c4598ed60040f4cf9f662bc809b31d2f0c77d5 100644 (file)
--- a/libcpp/types.hpp
+++ b/libcpp/types.hpp
@@ -27,14 +27,15 @@ using u32 = uint32_t;
 using i64 = int64_t;
 using u64 = uint64_t;
 
-using iptr = intptr_t;
-using uptr = uintptr_t;
-using dptr = __PTRDIFF_TYPE__;
-using nptr = decltype(nullptr);
+using ptr = intptr_t;
+constexpr auto nil = nullptr;
+using nil_t = decltype(nil);
 
 using size = i64;
+using diff = i64;
+static_assert(sizeof(diff) >= sizeof(__PTRDIFF_TYPE__));
 
-using pid = i64;
-using fd = i64;
+enum class pid : i64 {};
+enum class fd : i64 {};
 
 } // namespace amy

diff --git a/test_module/src/test.cpp b/test_module/src/test.cpp
index a66ecd260f0c08afaa4698c61a0eef57c3809dc5..421ce3fd6e68d908124ef0d65766d5e9db23ae70 100644 (file)
--- a/test_module/src/test.cpp
+++ b/test_module/src/test.cpp
@@ -37,8 +37,8 @@ extern "C" int close(amy::fd file);
 extern "C" void loop_de_loop();
 
 extern "C" void _start() {
-       sys::mount_kernel_device(-1, 'I', "/", 1, MOUNT_REPLACE); // 'I' is the I/O device. /serial is the serial port /fb is the framebuffer
-       const amy::fd serial = sys::open(-1, "/serial", 7, MODE_WRITE);
+       sys::mount_kernel_device(amy::fd(-1), 'I', "/", 1, MOUNT_REPLACE); // 'I' is the I/O device. /serial is the serial port /fb is the framebuffer
+       const amy::fd serial = sys::open(amy::fd(-1), "/serial", 7, MODE_WRITE);
 
        sys::write(serial, "Entrez votre nom: ", 18);
        char data[32];