IgrOS-Kernel 0.1.34.545
Simple C++20 Kernel for i386/x86_64
Loading...
Searching...
No Matches
kAlign.hpp
Go to the documentation of this file.
1
11
12
13#pragma once
14
15
16// C++
17#include <bit>
18#include <concepts>
19#include <type_traits>
20// IgrOS-Kernel arch
21#include <arch/types.hpp>
22
23
24// Kernel library code zone
25namespace igros::klib {
26
27
30 template<class T>
31 concept kalignable = std::unsigned_integral<T> || std::is_pointer_v<T>;
32
35 template<kalignable T>
36 using kalign_int_t = std::conditional_t<std::is_pointer_v<T>, igros_usize_t, T>;
37
38
40 class kAlign final {
41
46 template<igros_usize_t ALIGN, kalignable T>
47 [[nodiscard]]
48 consteval static auto alignment() noexcept -> igros_usize_t;
49
54 template<igros_usize_t ALIGN, kalignable T>
55 [[nodiscard]]
56 consteval static auto mask() noexcept -> kalign_int_t<T>;
57
62 template<kalignable T>
63 [[nodiscard]]
64 constexpr static auto integer(const T value) noexcept -> kalign_int_t<T>;
65
70 template<kalignable T>
71 [[nodiscard]]
72 constexpr static auto from(const kalign_int_t<T> value) noexcept -> T;
73
74
75 public:
76
82 template<igros_usize_t ALIGN = 0_usize, kalignable T>
83 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
84 [[nodiscard]]
85 constexpr static auto check(const T value) noexcept -> bool;
86
92 template<igros_usize_t ALIGN = 0_usize, kalignable T>
93 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
94 [[nodiscard]]
95 constexpr static auto up(const T value) noexcept -> T;
101 template<igros_usize_t ALIGN = 0_usize, kalignable T>
102 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
103 [[nodiscard]]
104 constexpr static auto down(const T value) noexcept -> T;
105 };
106
107
109 template<igros_usize_t ALIGN, kalignable T>
110 [[nodiscard]]
111 consteval auto kAlign::alignment() noexcept -> igros_usize_t {
112 if constexpr (0_usize != ALIGN) {
113 return ALIGN;
114 } else if constexpr (std::is_pointer_v<T> && !std::is_void_v<std::remove_pointer_t<T>>) {
115 return alignof(std::remove_pointer_t<T>);
116 } else {
117 return 1_usize;
118 }
119 }
120
122 template<igros_usize_t ALIGN, kalignable T>
123 [[nodiscard]]
124 consteval auto kAlign::mask() noexcept -> kalign_int_t<T> {
125 return static_cast<kalign_int_t<T>>(kAlign::alignment<ALIGN, T>() - 1_usize);
126 }
127
129 template<kalignable T>
130 [[nodiscard]]
131 constexpr auto kAlign::integer(const T value) noexcept -> kalign_int_t<T> {
132 if constexpr (std::is_pointer_v<T>) {
133 return std::bit_cast<igros_usize_t>(value);
134 } else {
135 return value;
136 }
137 }
138
140 template<kalignable T>
141 [[nodiscard]]
142 constexpr auto kAlign::from(const kalign_int_t<T> value) noexcept -> T {
143 if constexpr (std::is_pointer_v<T>) {
144 return std::bit_cast<T>(value);
145 } else {
146 return value;
147 }
148 }
149
150
152 template<igros_usize_t ALIGN, kalignable T>
153 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
154 [[nodiscard]]
155 constexpr auto kAlign::check(const T value) noexcept -> bool {
156 return 0 == (kAlign::integer(value) & kAlign::mask<ALIGN, T>());
157 }
158
160 template<igros_usize_t ALIGN, kalignable T>
161 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
162 [[nodiscard]]
163 constexpr auto kAlign::up(const T value) noexcept -> T {
164 constexpr auto MASK {kAlign::mask<ALIGN, T>()};
165 return kAlign::from<T>(static_cast<kalign_int_t<T>>((kAlign::integer(value) + MASK) & ~MASK));
166 }
167
169 template<igros_usize_t ALIGN, kalignable T>
170 requires (std::has_single_bit(ALIGN) || (0_usize == ALIGN))
171 [[nodiscard]]
172 constexpr auto kAlign::down(const T value) noexcept -> T {
173 constexpr auto MASK {kAlign::mask<ALIGN, T>()};
174 return kAlign::from<T>(static_cast<kalign_int_t<T>>(kAlign::integer(value) & ~MASK));
175 }
176
177
178} // namespace igros::klib
179
Kernel alignment handling (ALIGN in bytes, power of two; 0 - natural alignment of pointed type).
Definition kAlign.hpp:40
static constexpr auto from(const kalign_int_t< T > value) noexcept -> T
Integer as value.
Definition kAlign.hpp:142
static consteval auto alignment() noexcept -> igros_usize_t
Alignment in bytes.
Definition kAlign.hpp:111
static constexpr auto check(const T value) noexcept -> bool
Check alignment.
Definition kAlign.hpp:155
static consteval auto mask() noexcept -> kalign_int_t< T >
Alignment mask.
Definition kAlign.hpp:124
static constexpr auto up(const T value) noexcept -> T
Align up.
Definition kAlign.hpp:163
static constexpr auto integer(const T value) noexcept -> kalign_int_t< T >
Value as integer.
Definition kAlign.hpp:131
static constexpr auto down(const T value) noexcept -> T
Align down.
Definition kAlign.hpp:172
Alignable value: unsigned integer (address) or pointer.
Definition kAlign.hpp:31
std::size_t igros_usize_t
Unsigned size.
Definition types.hpp:51
Freestanding kernel library: printing, math, alignment, flags, strings.
std::conditional_t< std::is_pointer_v< T >, igros_usize_t, T > kalign_int_t
Integer type for alignment arithmetic (pointers as addresses, integers as is: 64-bit on i386 too).
Definition kAlign.hpp:36
Common C++ types redefinition.