diff options
Diffstat (limited to 'arch/x86_64/include')
8 files changed, 385 insertions, 30 deletions
diff --git a/arch/x86_64/include/arch/kernel/interrupt.hpp b/arch/x86_64/include/arch/kernel/interrupt.hpp deleted file mode 100644 index 521318d..0000000 --- a/arch/x86_64/include/arch/kernel/interrupt.hpp +++ /dev/null @@ -1,26 +0,0 @@ -#ifndef TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP -#define TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP - -#include <cstdint> - -namespace teachos::arch::kernel -{ - struct stack_frame - { - std::uint16_t instruction_pointer; - std::uint16_t cs; - std::uint16_t flags; - std::uint16_t sp; - std::uint16_t ss; - }; - - /** - * @brief Handles an interrupt - * - * https://clang.llvm.org/docs/AttributeReference.html#interrupt-x86 - */ - __attribute__((interrupt)) extern "C" auto interrupt_handler(struct stack_frame * frame) -> void; - -} // namespace teachos::arch::kernel - -#endif // TEACHOS_ARCH_X86_64_KERNEL_INTERRUPT_HPP diff --git a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp index 74734af..011f45c 100644 --- a/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/bump_allocator.hpp @@ -35,7 +35,7 @@ namespace teachos::arch::memory::heap * * @note Simply does nothing, because this allocator leaks all memory */ - auto deallocate(void * pointer) -> void override; + auto deallocate(void * pointer) noexcept -> void override; private: std::size_t heap_start; ///< Start of the allocatable heap area diff --git a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp index a1621b5..dff837e 100644 --- a/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/global_heap_allocator.hpp @@ -53,7 +53,7 @@ namespace teachos::arch::memory::heap * * @param pointer Previously allocated memory area, that should now be freed */ - static auto deallocate(void * pointer) -> void; + static auto deallocate(void * pointer) noexcept -> void; private: static heap_allocator * allocator_instance; ///< Instance used to actually allocate and deallocate diff --git a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp index 01657f2..6aed3d8 100644 --- a/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/heap_allocator.hpp @@ -36,7 +36,7 @@ namespace teachos::arch::memory::heap * * @param pointer Previously allocated memory area, that should now be freed */ - virtual auto deallocate(void * pointer) -> void = 0; + virtual auto deallocate(void * pointer) noexcept -> void = 0; }; } // namespace teachos::arch::memory::heap diff --git a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp index d53756d..df9e370 100644 --- a/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp +++ b/arch/x86_64/include/arch/memory/heap/linked_list_allocator.hpp @@ -35,7 +35,7 @@ namespace teachos::arch::memory::heap */ auto allocate(std::size_t size) -> void * override; - auto deallocate(void * pointer) -> void override; + auto deallocate(void * pointer) noexcept -> void override; private: /** diff --git a/arch/x86_64/include/arch/stl/shared_pointer.hpp b/arch/x86_64/include/arch/stl/shared_pointer.hpp new file mode 100644 index 0000000..79a9f82 --- /dev/null +++ b/arch/x86_64/include/arch/stl/shared_pointer.hpp @@ -0,0 +1,120 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP +#define TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP + +namespace teachos::arch::stl +{ + template<typename T> + struct shared_pointer + { + explicit shared_pointer(T * pointer = nullptr) + : pointer(pointer) + , ref_count(new std::atomic<int>(pointer != nullptr ? 1 : 0)) + { + } + + shared_pointer(const shared_pointer & other) + : pointer(other.pointer) + , ref_count(other.ref_count) + { + if (pointer != nullptr) + { + ++(*ref_count); + } + } + + shared_pointer(shared_pointer && other) noexcept + : pointer(other.pointer) + , ref_count(other.ref_count) + { + other.pointer = nullptr; + other.ref_count = nullptr; + } + + shared_pointer & operator=(const shared_pointer & other) + { + if (this != &other) + { + cleanup(); + pointer = other.pointer; + ref_count = other.ref_count; + + if (pointer != nullptr) + { + ++(*ref_count); + } + } + + return *this; + } + + shared_pointer & operator=(shared_pointer && other) noexcept + { + if (this != &other) + { + cleanup(); + pointer = other.pointer; + ref_count = other.ref_count; + other.pointer = nullptr; + other.ref_count = nullptr; + } + + return *this; + } + + ~shared_pointer() { cleanup(); } + + void cleanup() + { + if (pointer != nullptr && ref_count != nullptr && --(*ref_count) == 0) + { + delete pointer; + delete ref_count; + } + } + + void reset(T * p = nullptr) + { + cleanup(); + pointer = p; + ref_count = new std::atomic<int>(p != nullptr ? 1 : 0); + } + + void swap(shared_pointer & other) + { + std::swap(pointer, other.pointer); + std::swap(ref_count, other.ref_count); + } + + T & operator*() const { return *pointer; } + + T * operator->() const { return pointer; } + + T * get() const { return pointer; } + + int use_count() const + { + if (pointer != nullptr) + { + return *ref_count; + } + + return 0; + } + + bool unique() const { return use_count() == 1; } + + explicit operator bool() const { return pointer != nullptr; } + + private: + T * pointer; + std::atomic<int> * ref_count; + }; + + template<typename T, typename... Args> + shared_pointer<T> make_shared(Args &&... args) + { + return shared_pointer<T>(new T(std::forward<Args>(args)...)); + } +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_SHARED_POINTER_HPP
\ No newline at end of file diff --git a/arch/x86_64/include/arch/stl/unique_pointer.hpp b/arch/x86_64/include/arch/stl/unique_pointer.hpp new file mode 100644 index 0000000..0ec3c38 --- /dev/null +++ b/arch/x86_64/include/arch/stl/unique_pointer.hpp @@ -0,0 +1,68 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP +#define TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP + +namespace teachos::arch::stl +{ + template<typename T> + struct unique_pointer + { + explicit unique_pointer(T * ptr = nullptr) + : pointer(ptr) + { + } + + ~unique_pointer() { delete pointer; } + + unique_pointer(const unique_pointer &) = delete; + unique_pointer & operator=(const unique_pointer &) = delete; + + unique_pointer(unique_pointer && other) noexcept + : pointer(other.pointer) + { + other.pointer = nullptr; + } + + unique_pointer & operator=(unique_pointer && other) noexcept + { + if (this != &other) + { + delete pointer; + pointer = other.pointer; + other.pointer = nullptr; + } + return *this; + } + + T & operator*() const { return *pointer; } + + T * operator->() const { return pointer; } + + T * get() const { return pointer; } + + T * release() + { + T * temp = pointer; + pointer = nullptr; + return temp; + } + + void reset(T * ptr = nullptr) + { + delete pointer; + pointer = ptr; + } + + void swap(unique_pointer & other) { std::swap(pointer, other.pointer); } + + private: + T * pointer; + }; + + template<typename T, typename... Args> + unique_pointer<T> make_unique(Args &&... args) + { + return unique_pointer<T>(new T(std::forward<Args>(args)...)); + } +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_UNIQUE_POINTER_HPP
\ No newline at end of file diff --git a/arch/x86_64/include/arch/stl/vector.hpp b/arch/x86_64/include/arch/stl/vector.hpp new file mode 100644 index 0000000..62be704 --- /dev/null +++ b/arch/x86_64/include/arch/stl/vector.hpp @@ -0,0 +1,193 @@ +#ifndef TEACHOS_ARCH_X86_64_STL_VECTOR_HPP +#define TEACHOS_ARCH_X86_64_STL_VECTOR_HPP + +#include "arch/exception_handling/panic.hpp" +#include "arch/shared/container.hpp" +#include "arch/shared/contiguous_pointer_iterator.hpp" + +#include <algorithm> + +namespace teachos::arch::stl +{ + /** + * @brief Custom vector implementation mirroring the std::vector to allow for the usage of STL functionality with our + * custom memory management + * + * @tparam T Element the vector instance should contain + */ + template<typename T> + struct vector + { + /** + * @brief Defaulted constructor. Initalizes empty vector + */ + vector() = default; + + /** + * @brief Constructs data with the given amount of elements containg the given value or alterantively the default + * constructed value + * + * @param capacity Amount of elements we want to create and set the given value for + * @param initial Inital value of all elements in the underlying data array + */ + vector(size_t capacity, T initial = T{}) + : capacity(capacity) + , size(capacity) + , data(new T[capacity]{}) + { + auto const begin = data; + auto const end = data + size; + vector_container container{begin, end}; + std::ranges::fill(container, inital); + } + + /** + * @brief Copy constructor + * + * @note Allocates underlying data container with the same capacity as vector we are copying from and copies all + * elements from it + * + * @param other Other instance of vector we want to copy the data from + */ + vector(vector<T> const & other) + : size(size) + , capacity(capacity) + { + delete[] data; + data = new T[capacity]{}; + + auto const begin = other.data; + auto const end = other.data + size; + vector_container container{begin, end}; + std::ranges::copy(container, data); + } + + /** + * @brief Copy assignment operator + * + * @note Allocates underlying data container with the same capacity as vector we are copying from and copies all + * elements from it + * + * @param other Other instance of vector we want to copy the data from + * @return Newly created copy + */ + vector<T> & operator=(vector<T> const & other) + { + delete[] data; + size = other.size(); + capacity = other.capacity(); + data = new T[capacity]{}; + + auto const begin = other.data; + auto const end = other.data + size; + vector_container container{begin, end}; + std::ranges::copy(container, data); + return *this; + } + + /** + * @brief Destructor + */ + ~vector() { delete[] data; } + + /** + * @brief Amount of elements currently contained in this vector, will fill up until we have reached the capacity. If + * that is the case the capacity is increased automatically + * + * @return Current amount of elements + */ + size_t size() const { return size; } + + /** + * @brief Amount of space the vector currently has, can be different than the size, because we allocate more than we + * exactly require to decrease the amount of allocations and deallocation to improve speed + * + * @return Current amount of space the vector has for elements + */ + size_t capacity() const { return capacity; } + + /** + * @brief Array indexing operator. Allowing to access element at the given index + * + * @note Does not do any bounds checks use at() for that + * + * @param index Index we want to access elements at + * @return Reference to the underlying element + */ + T & operator[](size_t index) { return data[index]; } + + /** + * @brief Array indexing operator. Allowing to access element at the given index + * + * @note Ensures we do not access element outside of the bounds of the array, if we do further execution is halted + * + * @param index Index we want to access elements at + * @return Reference to the underlying element + */ + T & at(size_t index) + { + if (index >= size) + { + exception_handling::panic("[Vector] Attempted to read element at invalid index"); + } + return this->operator[](size); + } + + void push_back(T & const element) {} + + void emplace_back(T && const element) + { + // If no cacacity, increase capacity + if (size == capacity) + { + reserve(capacity * 2); + } + + data[size] = element; + size++; + } + + void pop_back() + { + if (size <= 0) + { + exception_handling::panic("[Vector] Attempted to pop back last element of already empty vector"); + } + size--; + } + + T & front() { return *data; } + + T & back() { return *(data + size); } + + void reserve(size_t new_capacity) + { + if (new_capacity < size) + { + // Creating new array with less capacity than is required to keep all current elements makes no sense + return; + } + + T * temp = new T[new_capacity]; + + auto const begin = other.data; + auto const end = other.data + capacity; + vector_container container{begin, end}; + std::ranges::copy(container, temp); + + delete[] data; + capacity = new_capacity; + data = temp; + } + + private: + T * data = {}; ///< Pointer to the first element in the underlying data container + size_t capacity = {}; ///< Amount of space for elements in the underlying data container + size_t size = {}; ///< Amount of elements in the underlying data container + + typedef shared::container<shared::contiguous_pointer_iterator<T>> vector_container; + }; + +} // namespace teachos::arch::stl + +#endif // TEACHOS_ARCH_X86_64_STL_VECTOR_HPP |